@@ -9,7 +9,8 @@ TUI_FORK_TESTS := test/ui/directory-link.test.ts test/ui/directory-markdown.test
 CORE_FORK_TESTS := test/plugin/custom.test.ts test/plugin/supervisor.test.ts test/tool-cancel.test.ts \
 	test/session-create.test.ts test/session-roots.test.ts test/session-skill.test.ts test/session-generate.test.ts \
 	test/session-owned.test.ts test/session-runner.test.ts test/tool-skill.test.ts test/file-access.test.ts \
-	test/bus-session-routing.test.ts test/subagent-lifetime.test.ts test/websearch.test.ts test/v1-migration.test.ts
+	test/bus-session-routing.test.ts test/subagent-lifetime.test.ts test/websearch.test.ts test/v1-migration.test.ts \
+	test/session-move.test.ts test/tool-opencode.test.ts
 SCHEMA_FORK_TESTS := test/event-manifest.test.ts
 SDK_FORK_TESTS := test/instances-effect.test.ts
 
@@ -23,10 +24,10 @@ build-single: typecheck
 	$(BUN) run --cwd packages/cli build --single
 
 tests: install-deps
-	cd packages/tui && $(BUN) test $(TUI_FORK_TESTS)
-	cd packages/core && $(BUN) test $(CORE_FORK_TESTS)
-	cd packages/schema && $(BUN) test $(SCHEMA_FORK_TESTS)
-	cd packages/sdk && $(BUN) test $(SDK_FORK_TESTS)
+	cd packages/tui && $(BUN) run test $(TUI_FORK_TESTS)
+	cd packages/core && $(BUN) run test $(CORE_FORK_TESTS)
+	cd packages/schema && $(BUN) run test $(SCHEMA_FORK_TESTS)
+	cd packages/sdk && $(BUN) run test $(SDK_FORK_TESTS)
 
 generate: install-deps
 	./script/generate.ts
@@ -137,13 +137,19 @@ Plugin (`custom.pull-requests` + TUI `custom.sidebar.pull-requests`): the sideba
 
 `cancel` tool: agents cancel a background `shell` or `subagent` they started by passing the shell ID or subagent `sessionID` from its `background: true` result (which now names the id); jobs owned by another session are refused.
 
-## Session Roots (Move Removed)
+## Session Roots
 
 Sessions keep one working directory (`location`) plus optional `roots`: extra directories that are in scope like the working directory, so reading and editing inside them skips `external_directory` approval. Add and remove roots with `session_root_add` / `session_root_remove` (Code Mode `opencode` namespace), `POST`/`DELETE /api/session/:sessionID/root`, or `session.root.add` / `session.root.remove` on the client and plugin APIs. Roots are event-sourced (`session.root.added` / `session.root.removed`), inherited by child sessions and forks, and listed in the system prompt; commands still run in the working directory.
 
 Roots are first-class context. `SessionRoots` (Location-scoped) discovers each root's instruction files (walked up to the root's project root, minus files the primary Location already loads and global config files) and skills (`.opencode/skill(s)`, `.claude/skills`, `.agents/skills`). `SessionContext.select` adds the root instructions as one `core/roots` instruction source and merges root skills into the available-skills list. The skill tool, `/skill` mentions, and `Session.skill` resolve skills through `SessionRoots.skill`: the primary Location wins an ID collision, then earlier roots. Discovery is not watched; it re-reads the filesystem on each step. A root's own `opencode.json` (config, `instructions`, `skills` entries, plugins) is not loaded.
 
-Moving a session is gone: the `session_move` tool, `/api/session/:sessionID/move`, the `SessionMove` service, and every UI entry point. `session.moved` and inbox `move` items stay decodable for old logs; the runner consumes legacy move items as no-ops. A session whose directory is missing is recovered by forking it into another directory (`session.fork` takes an optional `directory`).
+Session move is upstream's and unchanged: the `SessionMove` service, `/api/session/:sessionID/move`, the TUI and app entry points, and missing-directory recovery by moving. Roots and move are independent: a move changes `location` and keeps `roots`. `session.fork` also takes an optional `directory` that places the fork in another directory.
+
+In the TUI workspaces dialog, `ctrl+m` moves the session and `ctrl+y` (`dialog.workspaces.add_root`) adds the selected directory as a root.
+
+## Session Move Disabled for Models
+
+Plugin (`custom.tool.session-move.disable`): removes the `opencode_session_move` Code Mode tool after the builtin opencode tools register, so models cannot move a session. Users can still move sessions from the TUI, app, API, and SDK. The tool definition in `tool/plugin/opencode.ts` stays as upstream has it.
 
 ## Instruction Filenames
 
 
@@ -66,6 +66,262 @@ for (const endpoint of ["/api/location", "/api/agent"]) {
   }
 }
 
+test("replaces the composer when the location is not found and recovers by moving to another worktree", async ({
+  page,
+}) => {
+  const directory = "/projects/deleted-worktree"
+  const destination = "/projects/existing-worktree"
+  const sessionID = "ses_location_not_found"
+  const session = { id: sessionID, projectID: fixture.project.id, directory, title: "Missing location" }
+  const moves: unknown[] = []
+  const transport = await installSseTransport(page, { server: fixture.serverKey })
+  await mockOpenCodeServer(page, {
+    directory: fixture.directory,
+    project: fixture.project,
+    provider: fixture.provider,
+    sessions: [session],
+    fileList: () => [],
+    worktrees: [{ directory: fixture.directory }, { directory: destination, strategy: "git" }],
+    pageMessages: () => ({
+      items: [{ id: "msg_saved", type: "user", text: "Keep this session history", time: { created: 1 } }],
+    }),
+  })
+  let requests = 0
+  await page.route("**/api/location?**", (route) => {
+    if (new URL(route.request().url()).searchParams.get("location[directory]") !== directory) return route.fallback()
+    requests++
+
+    return route.fulfill({
+      status: 404,
+      // SAFETY: the server's wire body for a missing Location, which the client decodes into its own error.
+      // oxlint-disable-next-line anti-slop-effect/no-manual-tagged-construction -- see SAFETY above
+      json: { _tag: "LocationNotFoundError", location: { directory }, message: `Location not found: ${directory}` },
+      headers: { "access-control-allow-origin": "*" },
+    })
+  })
+  await page.route(`**/api/session/${sessionID}/move`, (route) => {
+    if (route.request().method() !== "POST") return route.fallback()
+    moves.push(route.request().postDataJSON())
+
+    return route.fulfill({ status: 204, headers: { "access-control-allow-origin": "*" } })
+  })
+
+  await page.goto(`/server/${base64Encode(fixture.serverKey)}/session/${sessionID}`)
+  const status = page.getByRole("group", { name: "Session location unavailable", exact: true })
+  await expect(status).toHaveAccessibleDescription(`${directory} Choose another directory to continue this session.`)
+  await expect(status).toContainText(directory)
+  await expect(page.getByText("Keep this session history", { exact: true })).toBeVisible()
+  await expect(page.getByRole("textbox", { name: "Prompt", exact: true })).toHaveCount(0)
+  // A typed not-found answer is final; retrying cannot succeed until the folder changes.
+  expect(requests).toBe(1)
+
+  await transport.waitForConnection()
+  await page.getByRole("button", { name: "Choose worktree", exact: true }).click()
+  await page.getByRole("menuitem", { name: "existing-worktree", exact: true }).click()
+  await expect.poll(() => moves).toEqual([{ directory: destination }])
+
+  session.directory = destination
+  await transport.send({
+    id: "evt_location_not_found_moved",
+    type: "session.moved",
+    created: 2,
+    durable: { aggregateID: sessionID, seq: 1, version: 1 },
+    data: { sessionID, location: { directory: destination }, projectID: fixture.project.id },
+  })
+  await expect(page.getByRole("textbox", { name: "Prompt", exact: true })).toBeEditable()
+  await expect(status).toHaveCount(0)
+  await expect(page.getByText("Keep this session history", { exact: true })).toBeVisible()
+})
+
+test("follows a live session move while the agent catalog is still loading", async ({ page }) => {
+  const recovery = recoveryRequests(page)
+  const directory = "/projects/old-tree"
+  const destination = "/projects/current-tree"
+  const sessionID = "ses_location_moved_while_loading"
+  const session = { id: sessionID, projectID: fixture.project.id, directory, title: "Moved session" }
+  const requested = Promise.withResolvers<void>()
+  const release = Promise.withResolvers<void>()
+  await page.addInitScript(() => {
+    localStorage.setItem(
+      "settings.v3",
+      JSON.stringify({ general: { timelineDetail: { notices: { placement: "separate" } } } }),
+    )
+  })
+  const transport = await installSseTransport(page, { server: fixture.serverKey })
+  await mockOpenCodeServer(page, {
+    directory: fixture.directory,
+    project: fixture.project,
+    provider: fixture.provider,
+    sessions: [session],
+    fileList: () => [],
+    pageMessages: () => ({
+      items: [{ id: "msg_saved", type: "user", text: "Follow the session move", time: { created: 1 } }],
+    }),
+  })
+  await page.route("**/api/**", async (route) => {
+    const url = new URL(route.request().url())
+
+    if (url.pathname === "/api/agent" && url.searchParams.get("location[directory]") === directory) {
+      requested.resolve()
+      await release.promise
+    }
+
+    return route.fallback()
+  })
+  await page.goto(`/server/${base64Encode(fixture.serverKey)}/session/${sessionID}`)
+  await requested.promise
+  const prompt = page.getByRole("textbox", { name: "Prompt", exact: true })
+  await expect(prompt).toBeEditable()
+  await prompt.fill("Keep this draft")
+  await expect(page.getByText("Session location unavailable", { exact: true })).toHaveCount(0)
+  await transport.waitForConnection()
+
+  const resolved = page.waitForResponse((response) => {
+    const url = new URL(response.url())
+
+    return url.pathname === "/api/agent" && url.searchParams.get("location[directory]") === destination && response.ok()
+  })
+
+  session.directory = destination
+  await transport.send({
+    id: "evt_location_moved_while_loading",
+    type: "session.moved",
+    created: 2,
+    durable: { aggregateID: sessionID, seq: 1, version: 1 },
+    data: { sessionID, location: { directory: destination }, projectID: fixture.project.id },
+  })
+  await resolved
+
+  const delayed = page.waitForResponse((response) => {
+    const url = new URL(response.url())
+
+    return url.pathname === "/api/agent" && url.searchParams.get("location[directory]") === directory && response.ok()
+  })
+
+  release.resolve()
+  await delayed
+  await expect(prompt).toBeEditable()
+  await expect(prompt).toHaveText("Keep this draft")
+  await expect(page.getByText("Follow the session move", { exact: true })).toBeVisible()
+  await expect(page.locator('[data-type="location-switched"]').getByText(destination, { exact: true })).toBeVisible()
+  await expect(page.getByText("Session location unavailable", { exact: true })).toHaveCount(0)
+  await expect(page.getByRole("button", { name: "Choose directory", exact: true })).toHaveCount(0)
+  expect(recovery).toEqual([])
+})
+
+test("keeps the side panel's tabs and selection when the session moves", async ({ page }) => {
+  const directory = "/projects/tabs-before-move"
+  const destination = "/projects/tabs-after-move"
+  const sessionID = "ses_location_moved_tabs"
+  const session = { id: sessionID, projectID: fixture.project.id, directory, title: "Moved tabs" }
+  const transport = await installSseTransport(page, { server: fixture.serverKey })
+  await mockOpenCodeServer(page, {
+    directory: fixture.directory,
+    project: fixture.project,
+    provider: fixture.provider,
+    sessions: [session],
+    fileList: () => [],
+    findFiles: (input) => ["README.md", "NOTES.md"].filter((name) => name.startsWith(input.query)),
+    fileContent: (path) => ({ type: "text", content: `contents:${session.directory}:${path}` }),
+    pageMessages: () => ({
+      items: [{ id: "msg_saved", type: "user", text: "Keep my tabs", time: { created: 1 } }],
+    }),
+  })
+  await page.goto(`/server/${base64Encode(fixture.serverKey)}/session/${sessionID}`)
+  await expect(page.getByRole("textbox", { name: "Prompt", exact: true })).toBeEditable()
+
+  const panel = page.getByRole("complementary", { name: "Review and files" })
+  const files = panel.getByRole("tab", { name: /\.md$/ })
+  const notes = panel.getByRole("tab", { name: "NOTES.md", exact: true })
+
+  // A lost selection would fall back to the first file tab, README.md, so NOTES.md stays selected only if it carries.
+  for (const name of ["README", "NOTES"]) {
+    await page.keyboard.press("ControlOrMeta+Shift+P")
+
+    const dialog = page.getByRole("dialog")
+    const search = dialog.getByRole("combobox")
+    await search.fill(name)
+    await expect(dialog.getByRole("option", { name: `/ ${name}.md`, exact: true })).toHaveAttribute(
+      "aria-selected",
+      "true",
+    )
+    await search.press("Enter")
+    await expect(dialog).toHaveCount(0)
+    await expect(panel.getByRole("tab", { name: `${name}.md`, exact: true })).toHaveAttribute("aria-selected", "true")
+  }
+
+  await expect(files).toHaveText(["README.md", "NOTES.md"])
+  await expect(panel.getByText(`contents:${directory}:NOTES.md`, { exact: true })).toBeVisible()
+
+  await transport.waitForConnection()
+
+  const resolved = page.waitForResponse((response) => {
+    const url = new URL(response.url())
+
+    return (
+      url.pathname === "/api/location" && url.searchParams.get("location[directory]") === destination && response.ok()
+    )
+  })
+
+  session.directory = destination
+  await transport.send({
+    id: "evt_location_moved_tabs",
+    type: "session.moved",
+    created: 2,
+    durable: { aggregateID: sessionID, seq: 1, version: 1 },
+    data: { sessionID, location: { directory: destination }, projectID: fixture.project.id },
+  })
+  await resolved
+  await expect(page.locator('[data-type="location-switched"]').getByText(destination, { exact: true })).toBeVisible()
+  await expect(files).toHaveText(["README.md", "NOTES.md"])
+  await expect(notes).toHaveAttribute("aria-selected", "true")
+  // The carried tab shows the file in the new directory.
+  await expect(panel.getByText(`contents:${destination}:NOTES.md`, { exact: true })).toBeVisible()
+})
+
+test("refreshes a session moved during disconnection without losing the draft", async ({ page }) => {
+  const recovery = recoveryRequests(page)
+  const directory = "/projects/before-reconnect"
+  const destination = "/projects/after-reconnect"
+  const sessionID = "ses_location_reconnect"
+  const session = { id: sessionID, projectID: fixture.project.id, directory, title: "Reconnected session" }
+  const transport = await installSseTransport(page, { server: fixture.serverKey })
+  await mockOpenCodeServer(page, {
+    directory: fixture.directory,
+    project: fixture.project,
+    provider: fixture.provider,
+    sessions: [session],
+    fileList: () => [],
+    pageMessages: () => ({
+      items: [{ id: "msg_saved", type: "user", text: "Resume in the current worktree", time: { created: 1 } }],
+    }),
+  })
+  await page.goto(`/server/${base64Encode(fixture.serverKey)}/session/${sessionID}`)
+  const prompt = page.getByRole("textbox", { name: "Prompt", exact: true })
+  await expect(prompt).toBeEditable()
+  await prompt.fill("Draft before disconnect")
+  const connection = await transport.waitForConnection()
+
+  const resolved = page.waitForResponse((response) => {
+    const url = new URL(response.url())
+
+    return (
+      url.pathname === "/api/location" && url.searchParams.get("location[directory]") === destination && response.ok()
+    )
+  })
+
+  session.directory = destination
+  await transport.close()
+  await transport.waitForConnection({ after: connection.id })
+  await resolved
+  await expect(prompt).toBeEditable()
+  await expect(prompt).toHaveText("Draft before disconnect")
+  await expect(page.getByText("Resume in the current worktree", { exact: true })).toBeVisible()
+  await expect(page.getByText("Session location unavailable", { exact: true })).toHaveCount(0)
+  await expect(page.getByRole("button", { name: "Choose directory", exact: true })).toHaveCount(0)
+  expect(recovery).toEqual([])
+})
+
 test("ignores an old failed location read after reconnecting", async ({ page }) => {
   const recovery = recoveryRequests(page)
   const directory = "/projects/reconnected-tree"
@@ -125,14 +381,14 @@ test("ignores an old failed location read after reconnecting", async ({ page })
   expect(recovery).toEqual([])
 })
 
-// Creating a worktree is recovery. Showing a resolved Location also refreshes its project's
+// Relocation: moving the session or creating a worktree. Showing a resolved Location also refreshes its project's
 // worktree inventory (`/api/worktree/refresh`), which is routine discovery, not recovery.
 function recoveryRequests(page: Page) {
   const requests: string[] = []
   page.on("request", (request) => {
     const path = new URL(request.url()).pathname
 
-    if (request.method() === "POST" && path === "/api/worktree") requests.push(path)
+    if (request.method() === "POST" && /^\/api\/(session\/[^/]+\/move|worktree)$/.test(path)) requests.push(path)
   })
 
   return requests
 
@@ -218,6 +218,50 @@ test("a subagent shows its details but cannot move to another worktree", async (
   await expect(location.getByRole("menuitem", { name: "feature", exact: true })).toBeDisabled()
 })
 
+test("the details follow the routed session when it moves to another worktree", async ({ page }) => {
+  const root = "C:/OpenCode/SmokeWorktrees"
+
+  const sessions = fixture.sessions.map((item) =>
+    item.id === fixture.targetID ? { ...item, directory: `${root}/feature` } : { ...item },
+  )
+
+  const mock = await mockStressTimeline(page, {
+    sessions,
+    worktrees: [
+      { directory: fixture.directory },
+      { directory: `${root}/feature`, strategy: "git" },
+      { directory: `${root}/other`, strategy: "git" },
+    ],
+  })
+
+  await page.goto(sessionHref(fixture.targetID))
+  const trigger = page.locator('[data-slot="session-location-trigger"]')
+  const summary = page.locator('[data-slot="session-location-card"]')
+  const location = (name: string) => summary.getByText(name, { exact: true })
+  await trigger.click()
+  await expect(location("feature")).toBeVisible()
+  await page.keyboard.press("Escape")
+  await expect(summary).toBeHidden()
+
+  // The server moves the session; the screen stays mounted while its plugins read the new worktree.
+  const moved = sessions.find((item) => item.id === fixture.targetID)
+
+  if (moved) moved.directory = `${root}/other`
+  await mock.push([
+    {
+      id: "evt_details_session_moved",
+      type: "session.moved",
+      created: 2,
+      durable: { aggregateID: fixture.targetID, seq: 1, version: 1 },
+      data: { sessionID: fixture.targetID, location: { directory: `${root}/other` }, projectID: fixture.project.id },
+    },
+  ])
+  await expect(trigger.locator('[data-slot="session-location-worktree"]')).toHaveText("other")
+  await trigger.click()
+  await expect(location("other")).toBeVisible()
+  await expect(location("feature")).toHaveCount(0)
+})
+
 for (const direction of ["ltr", "rtl"] as const) {
   test(`summary overlays the view and submenus follow ${direction}`, async ({ page }) => {
     await page.setViewportSize({ width: 1440, height: 900 })
 
@@ -20,14 +20,14 @@ export const dict = {
   "voice.failure.connection": "Couldn’t connect the call.",
   ...DESKTOP_NATIVE_ENGLISH,
   "session.location.unavailable": "Session location unavailable",
-  "session.location.description": "Fork this session into another directory to continue.",
+  "session.location.description": "Choose another directory to continue this session.",
   "session.location.choose": "Choose directory",
   "session.location.worktree": "Choose worktree",
   "session.location.worktreesFailed": "Failed to load worktrees",
   "session.rewind.toast.title": "Rewound",
   "session.rewind.toast.undo": "Undo",
-  "session.location.moving": "Forking session…",
-  "session.location.moveFailed": "Failed to fork session",
+  "session.location.moving": "Moving session…",
+  "session.location.moveFailed": "Failed to move session",
   "server.action.authenticate": "Authenticate",
   "server.status.connecting": "Connecting over SSH…",
   "server.thisComputer": "This computer",