feat(tui): add session migration dialog

packages/opencode/src/cli/cmd/tui/component/dialog-session-list.tsx

@@ -2,14 +2,17 @@ import { useDialog } from "@tui/ui/dialog"
 import { DialogSelect } from "@tui/ui/dialog-select"
 import { useRoute } from "@tui/context/route"
 import { useSync } from "@tui/context/sync"
-import { createMemo, createResource, createSignal, onMount } from "solid-js"
+import { createMemo, createSignal, createResource, onMount, Show } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
 import { Locale } from "@/util"
 import { useProject } from "@tui/context/project"
 import { useKeybind } from "../context/keybind"
 import { useTheme } from "../context/theme"
 import { useSDK } from "../context/sdk"
 import { Flag } from "@/flag/flag"
 import { DialogSessionRename } from "./dialog-session-rename"
+import { DialogSessionMigrate } from "./dialog-session-migrate"
+import { useKV } from "../context/kv"
 import { Keybind } from "@/util"
 import { createDebouncedSignal } from "../util/signal"
 import { useToast } from "../ui/toast"
@@ -174,6 +177,14 @@ export function DialogSessionList() {
     dialog.setSize("large")
   })
 
+  useKeyboard((evt) => {
+    if (keybind.match("session_migrate", evt)) {
+      evt.preventDefault()
+      evt.stopPropagation()
+      dialog.replace(() => <DialogSessionMigrate />)
+    }
+  })
+
   return (
     <DialogSelect
       title="Sessions"
@@ -247,6 +258,11 @@ export function DialogSessionList() {
             dialog.replace(() => <DialogSessionRename session={option.value} />)
           },
         },
+        {
+          keybind: keybind.all.session_migrate?.[0],
+          title: "migrate",
+          onTrigger: () => {},
+        },
         {
           keybind: Keybind.parse("ctrl+w")[0],
           title: "new workspace",

packages/opencode/src/cli/cmd/tui/component/dialog-session-migrate.tsx

@@ -0,0 +1,84 @@
+import { useDialog } from "@tui/ui/dialog"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { createResource, createMemo, createSignal, onMount, Show } from "solid-js"
+import { Locale } from "@/util"
+import { useSDK } from "../context/sdk"
+import { useTheme } from "../context/theme"
+import { useKeybind } from "../context/keybind"
+import { DialogSessionRescue } from "./dialog-session-rescue"
+import type { GlobalSession } from "@opencode-ai/sdk/v2"
+
+export function DialogSessionMigrate() {
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const { theme } = useTheme()
+  const keybind = useKeybind()
+  const [toDelete, setToDelete] = createSignal<string>()
+
+  const [data, { refetch }] = createResource(async () => {
+    const [res, orphans] = await Promise.all([
+      sdk.fetch(`${sdk.url}/experimental/session?roots=true&limit=200`),
+      sdk.client.session.orphans(),
+    ])
+    const all: GlobalSession[] = (await res.json()) ?? []
+    const ids = new Set((orphans.data ?? []).map((x) => x.id))
+    return { sessions: all, orphans: ids }
+  })
+
+  const options = createMemo(() => {
+    const items = data()
+    if (!items) return []
+    const deleting = toDelete()
+    return items.sessions.map((x) => ({
+      title: deleting === x.id ? `Press ${keybind.print("session_delete")} again to confirm` : x.title,
+      value: x.id,
+      description: x.directory,
+      footer: Locale.time(x.time.updated),
+      category: x.project?.name ?? x.project?.worktree ?? "global",
+      get gutter() {
+        return items.orphans.has(x.id) ? <text fg={theme.warning}>!</text> : undefined
+      },
+    }))
+  })
+
+  onMount(() => {
+    dialog.setSize("large")
+  })
+
+  return (
+    <box>
+      <DialogSelect
+        title="Migrate Session"
+        placeholder="Search sessions"
+        options={options()}
+        onSelect={(option) => {
+          const session = data()?.sessions.find((x) => x.id === option.value)
+          if (!session) return
+          dialog.replace(() => <DialogSessionRescue session={session} onDone={refetch} />)
+        }}
+        keybind={[
+          {
+            keybind: keybind.all.session_delete?.[0],
+            title: "delete",
+            onTrigger: async (option) => {
+              if (toDelete() === option.value) {
+                await sdk.client.session.delete({ sessionID: option.value })
+                setToDelete(undefined)
+                await refetch()
+                return
+              }
+              setToDelete(option.value)
+            },
+          },
+        ]}
+      />
+      <Show when={data()?.orphans.size}>
+        <box paddingLeft={4} paddingRight={4} paddingBottom={1}>
+          <text fg={theme.textMuted}>
+            NOTE: <span style={{ fg: theme.warning }}>!</span> means the session is orphan
+          </text>
+        </box>
+      </Show>
+    </box>
+  )
+}

packages/opencode/src/cli/cmd/tui/component/dialog-session-rescue.tsx

@@ -0,0 +1,94 @@
+import { useDialog } from "@tui/ui/dialog"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { createResource, createMemo, onMount } from "solid-js"
+import { useSDK } from "../context/sdk"
+import { useSync } from "../context/sync"
+import os from "os"
+
+interface MigrateSession {
+  id: string
+  title: string
+  directory: string
+  projectID: string
+  time: { created: number; updated: number }
+  project: { id: string; name?: string; worktree: string } | null
+}
+
+interface DialogSessionRescueProps {
+  session: MigrateSession
+  onDone: () => void
+}
+
+export function DialogSessionRescue(props: DialogSessionRescueProps) {
+  const dialog = useDialog()
+  const sdk = useSDK()
+  const sync = useSync()
+
+  const [data] = createResource(async () => {
+    const [cur, all] = await Promise.all([sdk.client.project.current(), sdk.client.project.list()])
+    return { current: cur.data, projects: all.data ?? [] }
+  })
+
+  const options = createMemo(() => {
+    const result: Array<{
+      title: string
+      value: { projectID: string; directory: string }
+      description?: string
+      category?: string
+    }> = []
+
+    const proj = data()?.current
+    if (proj) {
+      const dir = sdk.directory ?? proj.worktree
+      result.push({
+        title: proj.name ?? proj.worktree,
+        value: { projectID: proj.id, directory: dir },
+        description: dir,
+        category: "Current",
+      })
+    }
+
+    result.push({
+      title: "Home (~)",
+      value: { projectID: "global", directory: os.homedir() },
+      description: os.homedir(),
+      category: "Special",
+    })
+
+    for (const p of data()?.projects ?? []) {
+      if (p.id === proj?.id) continue
+      if (p.id === "global") continue
+      result.push({
+        title: p.name ?? p.worktree,
+        value: { projectID: p.id, directory: p.worktree },
+        description: p.worktree,
+        category: "Projects",
+      })
+    }
+
+    return result
+  })
+
+  onMount(() => {
+    dialog.setSize("large")
+  })
+
+  return (
+    <DialogSelect
+      title={`Migrate: ${props.session.title}`}
+      placeholder="Choose destination"
+      options={options()}
+      onSelect={async (option) => {
+        await sdk.client.session.migrate({
+          sessionID: props.session.id,
+          projectID: option.value.projectID,
+          body_directory: option.value.directory,
+        })
+        await sync.session.refresh()
+        props.onDone()
+        const { DialogSessionMigrate } = await import("./dialog-session-migrate")
+        dialog.replace(() => <DialogSessionMigrate />)
+      }}
+    />
+  )
+}

packages/opencode/src/config/keybinds.ts

@@ -30,6 +30,7 @@ const KeybindsSchema = Schema.Struct({
   session_fork: keybind("none", "Fork session from message"),
   session_rename: keybind("ctrl+r", "Rename session"),
   session_delete: keybind("ctrl+d", "Delete session"),
+  session_migrate: keybind("ctrl+o", "Migrate session to another project"),
   stash_delete: keybind("ctrl+d", "Delete stash entry"),
   model_provider_list: keybind("ctrl+a", "Open provider list from model dialog"),
   model_favorite_toggle: keybind("ctrl+f", "Toggle model favorite status"),

packages/opencode/src/server/routes/instance/session.ts

@@ -21,6 +21,7 @@ import { Log } from "@/util"
 import { Permission } from "@/permission"
 import { PermissionID } from "@/permission/schema"
 import { ModelID, ProviderID } from "@/provider/schema"
+import { ProjectID } from "@/project/schema"
 import { errors } from "../../error"
 import { lazy } from "@/util/lazy"
 import { Bus } from "@/bus"
@@ -100,6 +101,32 @@ export const SessionRoutes = lazy(() =>
           return Object.fromEntries(yield* svc.list())
         }),
     )
+    .get(
+      "/orphans",
+      describeRoute({
+        summary: "List orphaned sessions",
+        description:
+          "Get sessions whose directory no longer exists on disk. These sessions may have been orphaned when a project was moved or deleted.",
+        operationId: "session.orphans",
+        responses: {
+          200: {
+            description: "List of orphaned sessions",
+            content: {
+              "application/json": {
+                schema: resolver(Session.GlobalInfo.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const sessions: Session.GlobalInfo[] = []
+        for (const session of Session.listOrphans()) {
+          sessions.push(session)
+        }
+        return c.json(sessions)
+      },
+    )
     .get(
       "/:sessionID",
       describeRoute({
@@ -396,6 +423,44 @@ export const SessionRoutes = lazy(() =>
           return yield* svc.fork({ ...body, sessionID })
         }),
     )
+    .post(
+      "/:sessionID/migrate",
+      describeRoute({
+        summary: "Migrate session",
+        description: "Migrate a session to a new project and directory. Also migrates child sessions (sub-agents).",
+        operationId: "session.migrate",
+        responses: {
+          200: {
+            description: "Migrated session",
+            content: {
+              "application/json": {
+                schema: resolver(Session.Info),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator(
+        "param",
+        z.object({
+          sessionID: SessionID.zod,
+        }),
+      ),
+      validator(
+        "json",
+        z.object({
+          projectID: ProjectID.zod,
+          directory: z.string(),
+        }),
+      ),
+      async (c) => {
+        const sessionID = c.req.valid("param").sessionID
+        const body = c.req.valid("json")
+        const result = await Session.migrate({ ...body, sessionID })
+        return c.json(result)
+      },
+    )
     .post(
       "/:sessionID/abort",
       describeRoute({