@super-one/cli 0.74.0-alpha.2 → 0.75.0-alpha

package/lib/cli.mjs

@@ -137,8 +137,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.74.0-alpha.2".trim()) {
-    return "0.74.0-alpha.2".trim();
+  if ("0.75.0-alpha".trim()) {
+    return "0.75.0-alpha".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -510,7 +510,7 @@ var init_superone_tool_descriptions = __esm({
     ENVIRONMENT_GET_INFO_INCLUDE_DESCRIPTION = 'Detail groups to add. Default ["hardware"]; [] returns IDs, labels and state only.';
     ARCHIVE_ENVIRONMENT_DESCRIPTION = "Target environment ID from environment_get_info. Omit or use localhost for the calling session host.";
     LAYOUT_SNAPSHOT_DESCRIPTION = "Read the SuperOne desktop layout around your session: whether the user can see your chat, the sidebar, your activity panel (open, side, maximized), its tab groups (index and px box, so you can tell top/bottom from side by side) and tabs (id, kind, title, active, group, openedBy), your bottom terminal, the split view, chatMode and chatPosition, and sizes: px widths of the window, sidebar, panel and chat, with the min/max each column can take. Call it for tab and group ids before layout_act, for sizes before a resize, or to check what the user is looking at.";
-    LAYOUT_ACT_DESCRIPTION = "Arrange the SuperOne desktop for the user: open a file as a tab; focus or close tabs, move one beside or into a group or reorder it (move_tab), resize a group; show, hide, maximize, move or resize your activity panel; show or hide your terminal; show, hide or resize the sidebar (widen a column to narrow the chat); dock, float or iconify the chat; put a session you launched beside yours. Open browser and terminal tabs with browser_tabs / terminal_tabs. You can close only tabs and panes you opened. It never moves the user: in the background your own layout changes wait for them (status queued) and window-wide ones are skipped. `visible` says whether the user sees the result now.";
+    LAYOUT_ACT_DESCRIPTION = "Arrange the SuperOne desktop for the user: open a file as a tab; focus or close tabs, move one beside or into a group or reorder it (move_tab), resize a group; show, hide, maximize, move or resize your activity panel; show or hide your terminal; show, hide or resize the sidebar (widen a column to narrow the chat); dock, float or iconify the chat; put any other session beside yours. Open browser and terminal tabs with browser_tabs / terminal_tabs. It never moves the user: in the background your own layout changes wait for them (status queued) and window-wide ones are skipped. `visible` says whether the user sees the result now.";
     LAYOUT_ACT_PATH_DESCRIPTION = "open_file: the file, absolute or relative to your working folder.";
     LAYOUT_ACT_LINE_DESCRIPTION = "open_file: 1-based line to reveal.";
     LAYOUT_ACT_TAB_DESCRIPTION = "Tab id from layout_snapshot (browser_tabs / terminal_tabs ids work too). focus_tab, close_tab, move_tab; maximize_panel defaults to the active tab.";
@@ -521,7 +521,7 @@ var init_superone_tool_descriptions = __esm({
     LAYOUT_ACT_HEIGHT_DESCRIPTION = "resize_group: target height in px.";
     LAYOUT_ACT_MODE_DESCRIPTION = "chat_mode: docked (a column beside the panel), floating (a movable window over the panel, which then fills the window) or icon (that window collapsed).";
     LAYOUT_ACT_POSITION_DESCRIPTION = "chat_mode: where the floating chat or its icon snaps. Alone it moves the chat without changing mode; while docked it is kept for the next float.";
-    LAYOUT_ACT_SESSION_DESCRIPTION = "split_session / close_split: a session you launched with session_collab_*.";
+    LAYOUT_ACT_SESSION_DESCRIPTION = "split_session / close_split: a session id from session_list, session_search or session_collab_*.";
   }
 });
 
@@ -15634,6 +15634,23 @@ var init_session_runtime = __esm({
         }
         this.systemPromptAppends.set(sessionId, prompt.trim());
       }
+      /**
+       * `to` continues `from`, a collaboration child of a session on another
+       * machine: `to` becomes that child, with its parent and prompt, and `from`
+       * a plain session. No-op when `from` has no such parent.
+       */
+      moveExternalParent(from, to2) {
+        const source = this.live.get(from);
+        const target = this.live.get(to2);
+        const parent = source?.externalParent;
+        if (!source || !target || !parent) return;
+        target.externalParent = { sessionId: parent.sessionId };
+        source.externalParent = null;
+        this.systemPromptAppends.set(to2, collaborationSystemPrompt(parent.sessionId));
+        this.systemPromptAppends.delete(from);
+        this.persist(target);
+        this.persist(source);
+      }
       /** Set agent cwd (project root or worktree). Null clears to project default. */
       setCwd(sessionId, cwd) {
         const session = this.live.get(sessionId);
@@ -20939,11 +20956,246 @@ var init_sqlite_session_store = __esm({
   }
 });
 
+// ../../packages/shared/src/harness/acp-brand.ts
+function isGrokAcpAgent(agentId) {
+  if (!agentId) return false;
+  const id = agentId.toLowerCase();
+  return id.includes("grok");
+}
+function isOpenCodeAcpAgent(agentId) {
+  if (!agentId) return false;
+  return agentId.toLowerCase().includes("opencode");
+}
+function resolveHarnessBrandKey(harnessId, acpAgentId) {
+  if (!harnessId) return "claude";
+  if (harnessId !== "acp") return harnessId;
+  if (isGrokAcpAgent(acpAgentId)) return "acp-grok";
+  if (isOpenCodeAcpAgent(acpAgentId)) return "acp-opencode";
+  if (acpAgentId?.trim()) {
+    const short = acpAgentId.trim().toLowerCase().replace(/-build$/, "").replace(/[^a-z0-9]+/g, "-");
+    return short ? `acp-${short}` : "acp";
+  }
+  return "acp";
+}
+function acpAgentDisplayName(agentId, catalogName) {
+  if (catalogName?.trim()) {
+    return catalogName.trim().replace(/\s+Build$/i, "");
+  }
+  if (isGrokAcpAgent(agentId)) return "Grok";
+  if (isOpenCodeAcpAgent(agentId)) return "OpenCode";
+  if (agentId?.trim()) {
+    return agentId.trim().replace(/-build$/i, "").split(/[-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  }
+  return "ACP";
+}
+var init_acp_brand = __esm({
+  "../../packages/shared/src/harness/acp-brand.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/harness/harness-capabilities.ts
+function supportsShortWidgetResult(harnessId) {
+  return !!harnessId && Object.hasOwn(HARNESS_CAPABILITIES, harnessId) && HARNESS_CAPABILITIES[harnessId].supportsShortWidgetResult;
+}
+var HARNESS_CAPABILITIES, ALL_GOAL_LIFECYCLE_ARGS;
+var init_harness_capabilities = __esm({
+  "../../packages/shared/src/harness/harness-capabilities.ts"() {
+    "use strict";
+    init_acp_brand();
+    HARNESS_CAPABILITIES = {
+      claude: {
+        supportsMcp: true,
+        supportsPlanMode: true,
+        supportsTodos: true,
+        supportsSubagents: true,
+        supportsCompact: true,
+        supportsStreamingToolInput: true,
+        supportsQueuedSteer: true,
+        supportsQueuedSteerSoon: true,
+        // SDK `additionalDirectories`.
+        supportsAdditionalDirs: true,
+        // SDK `forkSession()` copies + remaps the transcript jsonl.
+        supportsFork: true,
+        supportsContextUsage: true,
+        softCancel: false,
+        // Built-in `/goal <condition>`: a Stop hook re-checks the condition after
+        // each turn and keeps going until it is met, so there is no paused state —
+        // the goal is either live or cleared.
+        goal: { lifecycleArgs: ["clear"], canPause: false, transport: "slash", semantics: "condition" },
+        terminalCommandApproval: "harness",
+        modUi: true,
+        supportsShortWidgetResult: true,
+        // `ultrathink` adds a deeper-reasoning reminder to the turn (effort is
+        // untouched); `ultracode` opts it into the Workflow tool, on messages stamped
+        // human — see `claudeMessageOrigin`.
+        promptKeywords: ["ultrathink", "ultracode"],
+        displayName: "Claude"
+      },
+      codex: {
+        supportsRealtimeVoice: true,
+        supportsMcp: true,
+        supportsPlanMode: true,
+        supportsTodos: false,
+        supportsSubagents: false,
+        supportsCompact: true,
+        supportsStreamingToolInput: false,
+        supportsQueuedSteer: true,
+        // Core's queue item either interrupts the turn or waits it out.
+        supportsQueuedSteerSoon: false,
+        // sandbox_workspace_write.writable_roots, re-sent every turn.
+        supportsAdditionalDirs: true,
+        // app-server thread fork, truncatable at a turn id.
+        supportsFork: true,
+        // Token usage arrives on the session snapshot only.
+        supportsContextUsage: false,
+        softCancel: false,
+        // `thread/goal/{get,set,clear}` over the app server; SuperOne drives the
+        // follow-up turns itself, so every transition is an explicit RPC.
+        goal: { lifecycleArgs: [], canPause: true, transport: "rpc", semantics: "objective" },
+        terminalCommandApproval: "harness",
+        modUi: false,
+        supportsShortWidgetResult: true,
+        promptKeywords: [],
+        displayName: "Codex"
+      },
+      acp: {
+        // Host injects SuperOne MCP on every ACP session; user MCP attach is a separate gap.
+        supportsMcp: true,
+        // Agent-driven plan + x.ai/exit_plan_mode approval is shipped (not host enter-plan).
+        supportsPlanMode: true,
+        // ACP session/update plan entries map to todo_write-style UI events.
+        supportsTodos: true,
+        // Subagent_* notifications already map to task rows, but there is no nested
+        // child chrome for ACP. Keep false until Task UI can host those sessions.
+        supportsSubagents: false,
+        // Host intercepts `/compact` → `x.ai/compact_conversation`.
+        supportsCompact: true,
+        supportsStreamingToolInput: false,
+        // Mid-turn send queues. Steer (`now`) is a new `session/prompt` with
+        // `_meta.sendNow`, which cancels the live turn and runs the message next.
+        // Steer soon is `x.ai/interject`: next safe point, the tool in flight stays.
+        supportsQueuedSteer: true,
+        supportsQueuedSteerSoon: true,
+        // session/new additionalDirectories, gated per agent capability.
+        supportsAdditionalDirs: true,
+        // Cold `x.ai/session/fork` copies Grok session files; SuperOne then resumes the child.
+        supportsFork: true,
+        supportsContextUsage: true,
+        softCancel: true,
+        // Grok only — see `resolveGoalCapability`. The agent owns the loop and
+        // reports back over `goal_updated`; the host just posts `/goal …` lines.
+        goal: {
+          lifecycleArgs: ["status", "pause", "resume", "clear"],
+          canPause: true,
+          transport: "slash",
+          semantics: "objective"
+        },
+        terminalCommandApproval: "harness",
+        modUi: false,
+        supportsShortWidgetResult: false,
+        promptKeywords: [],
+        displayName: "Others"
+      },
+      opencode: {
+        supportsMcp: true,
+        supportsPlanMode: true,
+        supportsTodos: true,
+        supportsSubagents: true,
+        supportsCompact: true,
+        supportsStreamingToolInput: false,
+        supportsQueuedSteer: false,
+        supportsQueuedSteerSoon: false,
+        // Single `directory` only.
+        supportsAdditionalDirs: false,
+        // Server-side `forkSession(id, anchor)` + `moveSession`.
+        supportsFork: true,
+        supportsContextUsage: true,
+        softCancel: true,
+        goal: null,
+        terminalCommandApproval: "harness",
+        modUi: false,
+        supportsShortWidgetResult: false,
+        promptKeywords: [],
+        displayName: "OpenCode"
+      },
+      cursor: {
+        supportsMcp: true,
+        supportsPlanMode: true,
+        // updateTodos / task tool deltas when event map lands (PR5+)
+        supportsTodos: true,
+        supportsSubagents: true,
+        supportsCompact: false,
+        supportsStreamingToolInput: true,
+        supportsQueuedSteer: false,
+        supportsQueuedSteerSoon: false,
+        // Single cwd; multi-root parked in the harness design doc.
+        supportsAdditionalDirs: false,
+        // SDK has no transcript-fork API; the adapter creates a blank agent.
+        supportsFork: false,
+        supportsContextUsage: true,
+        softCancel: false,
+        goal: null,
+        // The @cursor/sdk local executor auto-approves custom tools with no host hook.
+        terminalCommandApproval: "executor",
+        modUi: false,
+        supportsShortWidgetResult: false,
+        promptKeywords: [],
+        displayName: "Cursor"
+      },
+      dsh: {
+        // In-process dsh Cordis tree (docs/harness/dsh/deepseek-harness-integration.md).
+        // Flags flip only when the corresponding event path is wired.
+        // `supportsStreamingToolInput`: live `tool-call-delta` frames open the row
+        // and stream its arguments before the durable `tool/call` completes it.
+        // `supportsCompact`: `compaction-basic` compacts automatically at context
+        // pressure and on provider overflow; `/compact` drives `compactNow()`.
+        // `supportsMcp` covers both SuperOne's own tools (native dsh rows) and
+        // third-party servers read from dsh's own profile patch layer.
+        // `supportsSubagents`: foreground delegation (`dsh-tool-subagent` over the
+        // in-process spawn provider), rendered as a Task block with the child's
+        // steps nested under it. Background and continuable children are not wired.
+        // `supportsPlanMode`: `plan` also turns on dsh plan mode; `exit_plan_mode`
+        // reaches the plan-approval card through the user-questions seam.
+        // `supportsQueuedSteer`: `agent.steer()` lands at the next step boundary
+        // and never cancels a tool, so there is one steer and no separate "soon".
+        supportsMcp: true,
+        supportsPlanMode: true,
+        supportsTodos: true,
+        supportsSubagents: true,
+        supportsCompact: true,
+        supportsStreamingToolInput: true,
+        supportsQueuedSteer: true,
+        supportsQueuedSteerSoon: false,
+        // Single cwd.
+        supportsAdditionalDirs: false,
+        // `runtime.forkSession` copies the log prefix up to an event seq.
+        supportsFork: true,
+        supportsContextUsage: false,
+        softCancel: false,
+        goal: null,
+        terminalCommandApproval: "harness",
+        modUi: false,
+        supportsShortWidgetResult: false,
+        promptKeywords: [],
+        displayName: "DeepSeek"
+      }
+    };
+    ALL_GOAL_LIFECYCLE_ARGS = [...new Set(
+      Object.values(HARNESS_CAPABILITIES).flatMap((caps) => caps.goal?.lifecycleArgs ?? [])
+    )];
+  }
+});
+
 // ../../packages/shared/src/session-provider-definitions.ts
+function sessionProviderDisplayName(row2) {
+  return row2.isBase ? HARNESS_CAPABILITIES[row2.harnessId].displayName : row2.name;
+}
 var BASE_SESSION_PROVIDERS, BASE_SESSION_PROVIDER_DEFINITIONS;
 var init_session_provider_definitions = __esm({
   "../../packages/shared/src/session-provider-definitions.ts"() {
     "use strict";
+    init_harness_capabilities();
     BASE_SESSION_PROVIDERS = {
       claude: { id: "claude-base", name: "Claude (Base)", config: {} },
       codex: { id: "codex-base", name: "Codex (Base)", config: {} },
@@ -36579,237 +36831,6 @@ var init_slash_commands = __esm({
   }
 });
 
-// ../../packages/shared/src/harness/acp-brand.ts
-function isGrokAcpAgent(agentId) {
-  if (!agentId) return false;
-  const id = agentId.toLowerCase();
-  return id.includes("grok");
-}
-function isOpenCodeAcpAgent(agentId) {
-  if (!agentId) return false;
-  return agentId.toLowerCase().includes("opencode");
-}
-function resolveHarnessBrandKey(harnessId, acpAgentId) {
-  if (!harnessId) return "claude";
-  if (harnessId !== "acp") return harnessId;
-  if (isGrokAcpAgent(acpAgentId)) return "acp-grok";
-  if (isOpenCodeAcpAgent(acpAgentId)) return "acp-opencode";
-  if (acpAgentId?.trim()) {
-    const short = acpAgentId.trim().toLowerCase().replace(/-build$/, "").replace(/[^a-z0-9]+/g, "-");
-    return short ? `acp-${short}` : "acp";
-  }
-  return "acp";
-}
-function acpAgentDisplayName(agentId, catalogName) {
-  if (catalogName?.trim()) {
-    return catalogName.trim().replace(/\s+Build$/i, "");
-  }
-  if (isGrokAcpAgent(agentId)) return "Grok";
-  if (isOpenCodeAcpAgent(agentId)) return "OpenCode";
-  if (agentId?.trim()) {
-    return agentId.trim().replace(/-build$/i, "").split(/[-_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-  }
-  return "ACP";
-}
-var init_acp_brand = __esm({
-  "../../packages/shared/src/harness/acp-brand.ts"() {
-    "use strict";
-  }
-});
-
-// ../../packages/shared/src/harness/harness-capabilities.ts
-function supportsShortWidgetResult(harnessId) {
-  return !!harnessId && Object.hasOwn(HARNESS_CAPABILITIES, harnessId) && HARNESS_CAPABILITIES[harnessId].supportsShortWidgetResult;
-}
-var HARNESS_CAPABILITIES, ALL_GOAL_LIFECYCLE_ARGS;
-var init_harness_capabilities = __esm({
-  "../../packages/shared/src/harness/harness-capabilities.ts"() {
-    "use strict";
-    init_acp_brand();
-    HARNESS_CAPABILITIES = {
-      claude: {
-        supportsMcp: true,
-        supportsPlanMode: true,
-        supportsTodos: true,
-        supportsSubagents: true,
-        supportsCompact: true,
-        supportsStreamingToolInput: true,
-        supportsQueuedSteer: true,
-        supportsQueuedSteerSoon: true,
-        // SDK `additionalDirectories`.
-        supportsAdditionalDirs: true,
-        // SDK `forkSession()` copies + remaps the transcript jsonl.
-        supportsFork: true,
-        supportsContextUsage: true,
-        softCancel: false,
-        // Built-in `/goal <condition>`: a Stop hook re-checks the condition after
-        // each turn and keeps going until it is met, so there is no paused state —
-        // the goal is either live or cleared.
-        goal: { lifecycleArgs: ["clear"], canPause: false, transport: "slash", semantics: "condition" },
-        terminalCommandApproval: "harness",
-        modUi: true,
-        supportsShortWidgetResult: true,
-        // `ultrathink` adds a deeper-reasoning reminder to the turn (effort is
-        // untouched); `ultracode` opts it into the Workflow tool, on messages stamped
-        // human — see `claudeMessageOrigin`.
-        promptKeywords: ["ultrathink", "ultracode"],
-        displayName: "Claude"
-      },
-      codex: {
-        supportsRealtimeVoice: true,
-        supportsMcp: true,
-        supportsPlanMode: true,
-        supportsTodos: false,
-        supportsSubagents: false,
-        supportsCompact: true,
-        supportsStreamingToolInput: false,
-        supportsQueuedSteer: true,
-        // Core's queue item either interrupts the turn or waits it out.
-        supportsQueuedSteerSoon: false,
-        // sandbox_workspace_write.writable_roots, re-sent every turn.
-        supportsAdditionalDirs: true,
-        // app-server thread fork, truncatable at a turn id.
-        supportsFork: true,
-        // Token usage arrives on the session snapshot only.
-        supportsContextUsage: false,
-        softCancel: false,
-        // `thread/goal/{get,set,clear}` over the app server; SuperOne drives the
-        // follow-up turns itself, so every transition is an explicit RPC.
-        goal: { lifecycleArgs: [], canPause: true, transport: "rpc", semantics: "objective" },
-        terminalCommandApproval: "harness",
-        modUi: false,
-        supportsShortWidgetResult: true,
-        promptKeywords: [],
-        displayName: "Codex"
-      },
-      acp: {
-        // Host injects SuperOne MCP on every ACP session; user MCP attach is a separate gap.
-        supportsMcp: true,
-        // Agent-driven plan + x.ai/exit_plan_mode approval is shipped (not host enter-plan).
-        supportsPlanMode: true,
-        // ACP session/update plan entries map to todo_write-style UI events.
-        supportsTodos: true,
-        // Subagent_* notifications already map to task rows, but there is no nested
-        // child chrome for ACP. Keep false until Task UI can host those sessions.
-        supportsSubagents: false,
-        // Host intercepts `/compact` → `x.ai/compact_conversation`.
-        supportsCompact: true,
-        supportsStreamingToolInput: false,
-        // Mid-turn send queues. Steer (`now`) is a new `session/prompt` with
-        // `_meta.sendNow`, which cancels the live turn and runs the message next.
-        // Steer soon is `x.ai/interject`: next safe point, the tool in flight stays.
-        supportsQueuedSteer: true,
-        supportsQueuedSteerSoon: true,
-        // session/new additionalDirectories, gated per agent capability.
-        supportsAdditionalDirs: true,
-        // Cold `x.ai/session/fork` copies Grok session files; SuperOne then resumes the child.
-        supportsFork: true,
-        supportsContextUsage: true,
-        softCancel: true,
-        // Grok only — see `resolveGoalCapability`. The agent owns the loop and
-        // reports back over `goal_updated`; the host just posts `/goal …` lines.
-        goal: {
-          lifecycleArgs: ["status", "pause", "resume", "clear"],
-          canPause: true,
-          transport: "slash",
-          semantics: "objective"
-        },
-        terminalCommandApproval: "harness",
-        modUi: false,
-        supportsShortWidgetResult: false,
-        promptKeywords: [],
-        displayName: "Others"
-      },
-      opencode: {
-        supportsMcp: true,
-        supportsPlanMode: true,
-        supportsTodos: true,
-        supportsSubagents: true,
-        supportsCompact: true,
-        supportsStreamingToolInput: false,
-        supportsQueuedSteer: false,
-        supportsQueuedSteerSoon: false,
-        // Single `directory` only.
-        supportsAdditionalDirs: false,
-        // Server-side `forkSession(id, anchor)` + `moveSession`.
-        supportsFork: true,
-        supportsContextUsage: true,
-        softCancel: true,
-        goal: null,
-        terminalCommandApproval: "harness",
-        modUi: false,
-        supportsShortWidgetResult: false,
-        promptKeywords: [],
-        displayName: "OpenCode"
-      },
-      cursor: {
-        supportsMcp: true,
-        supportsPlanMode: true,
-        // updateTodos / task tool deltas when event map lands (PR5+)
-        supportsTodos: true,
-        supportsSubagents: true,
-        supportsCompact: false,
-        supportsStreamingToolInput: true,
-        supportsQueuedSteer: false,
-        supportsQueuedSteerSoon: false,
-        // Single cwd; multi-root parked in the harness design doc.
-        supportsAdditionalDirs: false,
-        // SDK has no transcript-fork API; the adapter creates a blank agent.
-        supportsFork: false,
-        supportsContextUsage: true,
-        softCancel: false,
-        goal: null,
-        // The @cursor/sdk local executor auto-approves custom tools with no host hook.
-        terminalCommandApproval: "executor",
-        modUi: false,
-        supportsShortWidgetResult: false,
-        promptKeywords: [],
-        displayName: "Cursor"
-      },
-      dsh: {
-        // In-process dsh Cordis tree (docs/harness/dsh/deepseek-harness-integration.md).
-        // Flags flip only when the corresponding event path is wired.
-        // `supportsStreamingToolInput`: live `tool-call-delta` frames open the row
-        // and stream its arguments before the durable `tool/call` completes it.
-        // `supportsCompact`: `compaction-basic` compacts automatically at context
-        // pressure and on provider overflow; `/compact` drives `compactNow()`.
-        // `supportsMcp` covers both SuperOne's own tools (native dsh rows) and
-        // third-party servers read from dsh's own profile patch layer.
-        // `supportsSubagents`: foreground delegation (`dsh-tool-subagent` over the
-        // in-process spawn provider), rendered as a Task block with the child's
-        // steps nested under it. Background and continuable children are not wired.
-        // `supportsPlanMode`: `plan` also turns on dsh plan mode; `exit_plan_mode`
-        // reaches the plan-approval card through the user-questions seam.
-        // `supportsQueuedSteer`: `agent.steer()` lands at the next step boundary
-        // and never cancels a tool, so there is one steer and no separate "soon".
-        supportsMcp: true,
-        supportsPlanMode: true,
-        supportsTodos: true,
-        supportsSubagents: true,
-        supportsCompact: true,
-        supportsStreamingToolInput: true,
-        supportsQueuedSteer: true,
-        supportsQueuedSteerSoon: false,
-        // Single cwd.
-        supportsAdditionalDirs: false,
-        // `runtime.forkSession` copies the log prefix up to an event seq.
-        supportsFork: true,
-        supportsContextUsage: false,
-        softCancel: false,
-        goal: null,
-        terminalCommandApproval: "harness",
-        modUi: false,
-        supportsShortWidgetResult: false,
-        promptKeywords: [],
-        displayName: "DeepSeek"
-      }
-    };
-    ALL_GOAL_LIFECYCLE_ARGS = [...new Set(
-      Object.values(HARNESS_CAPABILITIES).flatMap((caps) => caps.goal?.lifecycleArgs ?? [])
-    )];
-  }
-});
-
 // ../../packages/shared/src/session-goal.ts
 function sessionGoalFromClaudeActive(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
@@ -36911,6 +36932,22 @@ var init_plugin_notice_wire = __esm({
   }
 });
 
+// ../../packages/claude/src/artifact-result.ts
+function artifactResultTitle(toolName, toolUseResult) {
+  if (toolName !== "Artifact" || !toolUseResult || typeof toolUseResult !== "object") return void 0;
+  const result3 = toolUseResult;
+  const read5 = result3.read && typeof result3.read === "object" ? result3.read : null;
+  return nonEmpty2(result3.title) ?? nonEmpty2(read5?.title);
+}
+function nonEmpty2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+var init_artifact_result = __esm({
+  "../../packages/claude/src/artifact-result.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/claude/src/agent-event-mapper.ts
 function emptyResult(sessionId) {
   return {
@@ -37001,6 +37038,8 @@ function buildClaudeResultMetadata(result3, startedAt, pausedMs, lastAssistantUs
       cacheReadInputTokens: usage2.cache_read_input_tokens ?? 0,
       cacheCreationInputTokens: usage2.cache_creation_input_tokens ?? 0
     };
+    const cacheTtl = writtenCacheTtl(usage2.cache_creation);
+    if (cacheTtl) metadata.usage.cacheTtl = cacheTtl;
   }
   if (result3.modelUsage) {
     metadata.modelUsage = {};
@@ -37022,6 +37061,11 @@ function buildClaudeResultMetadata(result3, startedAt, pausedMs, lastAssistantUs
   }
   return metadata;
 }
+function writtenCacheTtl(cacheCreation) {
+  if ((cacheCreation?.ephemeral_1h_input_tokens ?? 0) > 0) return "1h";
+  if ((cacheCreation?.ephemeral_5m_input_tokens ?? 0) > 0) return "5m";
+  return void 0;
+}
 function createClaudeAgentEventMapper(options) {
   const now = options.now ?? Date.now;
   const startedAt = options.startedAt ?? now();
@@ -37064,6 +37108,7 @@ function createClaudeAgentEventMapper(options) {
     const outputPath = isBash ? extractBashOutputPath(text2) : void 0;
     const isTimedOut = isBash ? extractBashKilled(toolUseResult) : void 0;
     const taskCreateTodo = extractTaskCreateTodo(toolName, toolUseResult, text2);
+    const resultTitle = artifactResultTitle(toolName, toolUseResult);
     const isError = isClaudeToolLayerError(toolName, sdkIsError, text2);
     const app = options.toolApps?.toolResult(toolUseId, toolUseResult, sdkIsError, content);
     emit({
@@ -37077,6 +37122,7 @@ function createClaudeAgentEventMapper(options) {
         ...isTimedOut ? { isTimedOut } : {},
         ...isError ? { isError: true } : {},
         ...taskCreateTodo ?? {},
+        ...resultTitle ? { resultTitle } : {},
         parentToolUseId,
         ...app ? { app } : {}
       },
@@ -37638,6 +37684,7 @@ var init_agent_event_mapper2 = __esm({
     init_session_goal();
     init_result_failure();
     init_plugin_notice_wire();
+    init_artifact_result();
   }
 });
 
@@ -98425,7 +98472,10 @@ var BUILTIN_TOOL_INPUT_FIELDS = {
   TaskList: ["status"],
   TodoList: ["total", "completed"],
   UpdateGoal: ["message", "blocked_reason"],
-  Artifact: ["action", "scope", "title"],
+  Artifact: ["action", "scope", "title", "file_path", "url"],
+  ArtifactComments: ["action"],
+  ArtifactData: ["action", "collection", "doc_id"],
+  ArtifactCheck: ["action"],
   SandboxNetworkAccess: ["host"],
   ToolSearch: ["query"],
   SearchTools: ["query"],
@@ -102062,6 +102112,10 @@ async function handleSessionCreate(payload, ctx) {
   if (p3.externalParent != null && !externalParentSessionId) {
     return { error: { code: "invalid_argument", message: "externalParent.sessionId is required" } };
   }
+  if (p3.continuesFrom != null && typeof p3.continuesFrom !== "string") {
+    return { error: { code: "invalid_argument", message: "continuesFrom must be a string" } };
+  }
+  const continuesFrom = typeof p3.continuesFrom === "string" && p3.continuesFrom.trim() ? p3.continuesFrom.trim() : null;
   try {
     const agentSettings = loadNodeAgentSettings(ctx.settingsConfigPath);
     const defaults2 = resolveAgentTurnDefaults(agentSettings, harnessId);
@@ -102122,7 +102176,18 @@ async function handleSessionCreate(payload, ctx) {
       ctx.drafts.assertControl(selections.draftId, ctx.client.clientSessionId, selections.draftLeaseId);
     };
     assertCreate();
-    let session = ctx.sessions.createOnHost ? await ctx.sessions.createOnHost({ ...createInput, ...selections }, { settings: initialSettings, assertCreate }) : ctx.sessions.create(createInput);
+    const continuation = continuesFrom && !ctx.sessions.createOnHost ? ctx.collaboration : void 0;
+    if (continuesFrom && !ctx.sessions.createOnHost) {
+      if (!continuation?.assertContinuable || !continuation.continueSession) {
+        throw Object.assign(new Error("This host cannot continue a session in a new one"), { code: "unsupported" });
+      }
+      continuation.assertContinuable(continuesFrom);
+    }
+    let session = ctx.sessions.createOnHost ? await ctx.sessions.createOnHost(
+      { ...createInput, ...selections, ...continuesFrom ? { continuesFrom } : {} },
+      { settings: initialSettings, assertCreate }
+    ) : ctx.sessions.create(createInput);
+    if (continuesFrom && continuation) continuation.continueSession(continuesFrom, session.sessionId);
     if (!ctx.sessions.createOnHost && (model || effort || permissionMode || sandboxMode || Object.keys(extras).length)) {
       session = await ctx.sessions.patchSettings(session.sessionId, {
         ...extras,
@@ -109019,6 +109084,364 @@ import Database5 from "better-sqlite3";
 import { mkdirSync as mkdirSync24 } from "node:fs";
 import { dirname as dirname20 } from "node:path";
 
+// ../../packages/runtime/src/collaboration/store.ts
+import { randomUUID as randomUUID17 } from "node:crypto";
+
+// ../../packages/runtime/src/collaboration/errors.ts
+var CollaborationError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CollaborationError";
+  }
+  code;
+};
+
+// ../../packages/runtime/src/collaboration/store.ts
+var SESSION_CONTINUATION_TABLE_DDL = `
+CREATE TABLE IF NOT EXISTS session_continuations (
+  from_session_id TEXT PRIMARY KEY NOT NULL,
+  to_session_id TEXT NOT NULL UNIQUE,
+  created_at TEXT NOT NULL
+);
+`;
+var MAX_CONTINUATION_HOPS = 64;
+var GRANT_COLUMNS = `credential_hash AS grant_id, parent_session_id, child_session_id,
+  agent_id, task, config_json, task_sent, COALESCE(kind, 'spawn') AS kind, started_at`;
+var MESSAGE_COLUMNS = `id, sequence, sender_session_id, recipient_session_id, client_message_id, content, created_at`;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var CollaborationStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  // --- grants --------------------------------------------------------------
+  grantById(grantId) {
+    return this.db.prepare(`SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants WHERE credential_hash = ?`).get(grantId) ?? null;
+  }
+  /**
+   * The grant an approved launch created. launchIds are agent-chosen and may
+   * repeat across requests, so the latest approval wins.
+   */
+  grantForLaunch(parentSessionId, launchId) {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE parent_session_id = ? AND json_extract(config_json, '$.launchId') = ?
+      ORDER BY created_at DESC, rowid DESC LIMIT 1
+    `).get(parentSessionId, launchId) ?? null;
+  }
+  /** True when `sessionId` is a spawn child (nested collaboration is unsupported). */
+  isSpawnChild(sessionId) {
+    return Boolean(this.db.prepare(`
+      SELECT 1 FROM session_collaboration_grants
+      WHERE child_session_id = ? AND COALESCE(kind, 'spawn') = 'spawn' LIMIT 1
+    `).get(sessionId));
+  }
+  spawnGrantForChild(childSessionId) {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE child_session_id = ? AND COALESCE(kind, 'spawn') = 'spawn'
+    `).get(childSessionId) ?? null;
+  }
+  startedSpawnGrants() {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE child_session_id IS NOT NULL AND COALESCE(kind, 'spawn') = 'spawn'
+    `).all();
+  }
+  /** Started handoff grants; the session each created is `config_json.handoffSessionId`. */
+  startedHandoffGrants() {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE kind = 'handoff' AND started_at IS NOT NULL
+    `).all();
+  }
+  /**
+   * Open mailbox channels of `sessionId`: spawn grants with a bound child and
+   * started link grants, oldest first. Handoff grants are never channels.
+   */
+  channelsFor(sessionId) {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE (parent_session_id = ? OR child_session_id = ?)
+        AND child_session_id IS NOT NULL
+        AND (COALESCE(kind, 'spawn') = 'spawn' OR (kind = 'link' AND started_at IS NOT NULL))
+      ORDER BY created_at, rowid
+    `).all(sessionId, sessionId);
+  }
+  /** True when one of the two sessions was created by a handoff from the other. */
+  isHandoffPair(a, b3) {
+    return Boolean(this.db.prepare(`
+      SELECT 1 FROM session_collaboration_grants
+      WHERE kind = 'handoff' AND (
+        (parent_session_id = ? AND json_extract(config_json, '$.handoffSessionId') = ?)
+        OR (parent_session_id = ? AND json_extract(config_json, '$.handoffSessionId') = ?)
+      ) LIMIT 1
+    `).get(a, b3, b3, a));
+  }
+  findLinkGrant(initiatorSessionId, peerSessionId) {
+    return this.db.prepare(`
+      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
+      WHERE parent_session_id = ? AND child_session_id = ? AND kind = 'link'
+    `).get(initiatorSessionId, peerSessionId) ?? null;
+  }
+  /**
+   * Persist an approved launch. Link grants bind the peer at once; spawn and
+   * handoff grants bind their session on start. The brief arrives on start.
+   */
+  createGrant(input) {
+    const grantId = randomUUID17();
+    try {
+      this.db.prepare(`
+        INSERT INTO session_collaboration_grants
+          (credential_hash, credential_secret, credential_hint, parent_session_id, child_session_id,
+           agent_id, task, config_json, created_at, kind)
+        VALUES (?, NULL, '', ?, ?, ?, '', ?, ?, ?)
+      `).run(
+        grantId,
+        input.parentSessionId,
+        input.childSessionId ?? null,
+        input.agentId,
+        JSON.stringify(input.config),
+        nowIso(),
+        input.kind
+      );
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      if (input.childSessionId && /UNIQUE|unique/i.test(message)) {
+        throw new CollaborationError(
+          `Session ${input.parentSessionId} already has a link to ${input.childSessionId}; request it again to reuse it.`,
+          "failed_precondition"
+        );
+      }
+      throw error51;
+    }
+    return grantId;
+  }
+  updateConfig(grantId, config2) {
+    this.db.prepare("UPDATE session_collaboration_grants SET config_json = ? WHERE credential_hash = ?").run(JSON.stringify(config2), grantId);
+  }
+  /** Record the brief of a grant whose task has not been delivered yet. */
+  setTask(grantId, task) {
+    this.db.prepare("UPDATE session_collaboration_grants SET task = ? WHERE credential_hash = ? AND task_sent = 0").run(task, grantId);
+  }
+  markTaskSent(grantId) {
+    this.db.prepare("UPDATE session_collaboration_grants SET task_sent = 1 WHERE credential_hash = ?").run(grantId);
+  }
+  /** Link start. Returns false when the grant had already been started. */
+  markStarted(grantId) {
+    return this.db.prepare(`
+      UPDATE session_collaboration_grants SET started_at = ? WHERE credential_hash = ? AND started_at IS NULL
+    `).run(nowIso(), grantId).changes === 1;
+  }
+  /**
+   * Record the session a spawn/handoff start created. Throws when a concurrent
+   * start already consumed the grant.
+   *
+   * A handoff session is deliberately *not* written to child_session_id: that
+   * column holds channel endpoints (spawn children, link peers), and a handoff
+   * sibling is neither. The created id lives in config_json instead.
+   */
+  bindStartedSession(grant, sessionId, config2) {
+    const changes = grant.kind === "handoff" ? this.db.prepare(`
+          UPDATE session_collaboration_grants SET config_json = ?, started_at = ?
+          WHERE credential_hash = ? AND started_at IS NULL
+        `).run(JSON.stringify({ ...config2, handoffSessionId: sessionId }), nowIso(), grant.grant_id).changes : this.db.prepare(`
+          UPDATE session_collaboration_grants SET child_session_id = ?, started_at = ?
+          WHERE credential_hash = ? AND child_session_id IS NULL
+        `).run(sessionId, nowIso(), grant.grant_id).changes;
+    if (changes !== 1) throw new CollaborationError("This launch was already started", "failed_precondition");
+  }
+  // --- continuation --------------------------------------------------------
+  /** The session `sessionId` was continued in; null when it was not. */
+  successorOf(sessionId) {
+    const row2 = this.db.prepare("SELECT to_session_id FROM session_continuations WHERE from_session_id = ?").get(sessionId);
+    return row2?.to_session_id ?? null;
+  }
+  /** The session `sessionId` continues; null when it continues none. */
+  predecessorOf(sessionId) {
+    const row2 = this.db.prepare("SELECT from_session_id FROM session_continuations WHERE to_session_id = ?").get(sessionId);
+    return row2?.from_session_id ?? null;
+  }
+  /** The newest session in `sessionId`'s continuation chain (itself when never continued). */
+  currentSessionFor(sessionId) {
+    let current = sessionId;
+    for (let hop = 0; hop < MAX_CONTINUATION_HOPS; hop++) {
+      const next = this.successorOf(current);
+      if (!next) return current;
+      current = next;
+    }
+    return current;
+  }
+  /**
+   * Record that `to` continues `from`, and move `from`'s mailbox channels
+   * (spawn grants with a bound child, started link grants) with their
+   * messages and read cursors to `to`. Handoff and not-yet-started grants
+   * stay: their launch ids live in `from`'s transcript.
+   *
+   * Messages move on both sides so idempotency keys and report history follow
+   * the session, and deleting `from` no longer cascades them away. Returns the
+   * moved grants as they are now.
+   */
+  continueSession(from, to2) {
+    return this.transaction(() => {
+      const successor = this.successorOf(from);
+      if (successor) {
+        throw new CollaborationError(`Session ${from} was already continued in ${successor}`, "failed_precondition");
+      }
+      this.db.prepare("INSERT INTO session_continuations (from_session_id, to_session_id, created_at) VALUES (?, ?, ?)").run(from, to2, nowIso());
+      const grantIds = this.channelsFor(from).map((grant) => grant.grant_id);
+      for (const grantId of grantIds) {
+        for (const column of ["parent_session_id", "child_session_id"]) {
+          this.db.prepare(`UPDATE session_collaboration_grants SET ${column} = ? WHERE credential_hash = ? AND ${column} = ?`).run(to2, grantId, from);
+        }
+        for (const column of ["sender_session_id", "recipient_session_id"]) {
+          this.db.prepare(`UPDATE session_collaboration_messages SET ${column} = ? WHERE credential_hash = ? AND ${column} = ?`).run(to2, grantId, from);
+        }
+        this.db.prepare("UPDATE session_collaboration_cursors SET session_id = ? WHERE credential_hash = ? AND session_id = ?").run(to2, grantId, from);
+      }
+      return grantIds.map((grantId) => this.grantById(grantId));
+    });
+  }
+  // --- mailbox -------------------------------------------------------------
+  nextSequence(grantId) {
+    const row2 = this.db.prepare(`
+      SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence
+      FROM session_collaboration_messages WHERE credential_hash = ?
+    `).get(grantId);
+    return row2.next_sequence;
+  }
+  insertMessage(grantId, input) {
+    const row2 = {
+      id: randomUUID17(),
+      sequence: this.nextSequence(grantId),
+      sender_session_id: input.senderSessionId,
+      recipient_session_id: input.recipientSessionId,
+      client_message_id: input.clientMessageId,
+      content: input.content,
+      created_at: nowIso()
+    };
+    this.db.prepare(`
+      INSERT INTO session_collaboration_messages
+        (id, credential_hash, sequence, sender_session_id, recipient_session_id, client_message_id, content, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      row2.id,
+      grantId,
+      row2.sequence,
+      row2.sender_session_id,
+      row2.recipient_session_id,
+      row2.client_message_id,
+      row2.content,
+      row2.created_at
+    );
+    return row2;
+  }
+  /** Append one message; a repeated `clientMessageId` returns the stored row. */
+  appendMessage(input) {
+    return this.transaction(() => {
+      if (input.clientMessageId) {
+        const existing = this.db.prepare(`
+          SELECT ${MESSAGE_COLUMNS} FROM session_collaboration_messages
+          WHERE credential_hash = ? AND sender_session_id = ? AND client_message_id = ?
+        `).get(input.grantId, input.senderSessionId, input.clientMessageId);
+        if (existing) return { row: existing, reused: true };
+      }
+      const row2 = this.insertMessage(input.grantId, { ...input, clientMessageId: input.clientMessageId ?? null });
+      return { row: row2, reused: false };
+    });
+  }
+  /** When `sessionId` last sent and last received a mailbox message (ISO), across all its channels. */
+  lastMessageTimes(sessionId) {
+    return this.db.prepare(`
+      SELECT
+        (SELECT MAX(created_at) FROM session_collaboration_messages WHERE sender_session_id = ?) AS sentAt,
+        (SELECT MAX(created_at) FROM session_collaboration_messages WHERE recipient_session_id = ?) AS receivedAt
+    `).get(sessionId, sessionId);
+  }
+  /** Queue a link grant's opening body for the peer exactly once, then mark the task sent. */
+  appendLinkOpening(grant, recipientSessionId, content) {
+    this.transaction(() => {
+      try {
+        this.insertMessage(grant.grant_id, {
+          senderSessionId: grant.parent_session_id,
+          recipientSessionId,
+          clientMessageId: `link-opening:${grant.grant_id}`,
+          content
+        });
+      } catch {
+      }
+      this.markTaskSent(grant.grant_id);
+    });
+  }
+  /**
+   * Up to `limit` unread messages addressed to `sessionId` across grants,
+   * without marking them read: one per grant in turn, grants with the oldest
+   * unread message first, so successive reads reach every grant even when
+   * there are more grants than `limit`. Each batch is a prefix of its grant's
+   * unread messages. Selection reads only the mailbox index; bodies load for
+   * the selected messages alone.
+   */
+  peekMailbox(sessionId, grantIds, limit2) {
+    const unread = this.db.prepare(`
+      SELECT rowid AS rid FROM session_collaboration_messages
+      WHERE credential_hash = ? AND recipient_session_id = ? AND sequence > ?
+      ORDER BY sequence LIMIT ?
+    `);
+    const createdAt = this.db.prepare("SELECT created_at FROM session_collaboration_messages WHERE rowid = ?");
+    const queues2 = grantIds.flatMap((grantId) => {
+      const cursor = this.db.prepare(`
+        SELECT last_sequence FROM session_collaboration_cursors WHERE credential_hash = ? AND session_id = ?
+      `).get(grantId, sessionId);
+      const rids = unread.all(grantId, sessionId, cursor?.last_sequence ?? 0, limit2).map((row2) => row2.rid);
+      if (rids.length === 0) return [];
+      const oldest = createdAt.get(rids[0]).created_at;
+      return [{ grantId, rids, oldest, taken: 0 }];
+    }).sort((a, b3) => a.oldest.localeCompare(b3.oldest));
+    let budget = limit2;
+    while (budget > 0) {
+      let took = false;
+      for (const queue of queues2) {
+        if (budget === 0) break;
+        if (queue.taken === queue.rids.length) continue;
+        queue.taken++;
+        budget--;
+        took = true;
+      }
+      if (!took) break;
+    }
+    const load = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM session_collaboration_messages WHERE rowid = ?`);
+    return queues2.filter((queue) => queue.taken > 0).map(({ grantId, rids, taken }) => ({
+      grantId,
+      rows: rids.slice(0, taken).map((rid) => load.get(rid))
+    }));
+  }
+  /**
+   * Mark messages read up to each grant's `lastSequence`. A cursor never
+   * moves back, so acknowledgements may arrive in any order.
+   */
+  ackMailbox(sessionId, acks) {
+    this.transaction(() => {
+      for (const { grantId, lastSequence } of acks) {
+        this.db.prepare(`
+          INSERT INTO session_collaboration_cursors (credential_hash, session_id, last_sequence)
+          VALUES (?, ?, ?)
+          ON CONFLICT(credential_hash, session_id) DO UPDATE SET last_sequence = MAX(last_sequence, excluded.last_sequence)
+        `).run(grantId, sessionId, lastSequence);
+        this.db.prepare(`
+          UPDATE session_collaboration_messages SET delivered_at = COALESCE(delivered_at, ?)
+          WHERE credential_hash = ? AND recipient_session_id = ? AND sequence <= ?
+        `).run(nowIso(), grantId, sessionId, lastSequence);
+      }
+    });
+  }
+};
+
 // ../../packages/shared/src/session-interruption.ts
 function isNodeRestartInterruption(reason) {
   return reason === "node_restart" || reason === "node_restart_non_reattachable";
@@ -109105,6 +109528,26 @@ var CollaborationWakeQueue = class {
       this.start();
     }
   }
+  /** True while a wake for `sessionId` is being prepared or handed to its harness. */
+  hasInFlight(sessionId) {
+    if (this.delivering.has(sessionId)) return true;
+    return Boolean(this.db.prepare(`SELECT 1 FROM collaboration_wakes
+      WHERE session_id = ? AND state IN ('preparing', 'dispatching') LIMIT 1`).get(sessionId));
+  }
+  /**
+   * Hand `from`'s wakes to `to`, the session that continues it. Settled rows
+   * move too, so deduplication by notification id keeps holding for the new
+   * recipient. `to` starts paused: its own first output (see {@link observe})
+   * releases the moved wakes, so none runs ahead of the turn the user starts.
+   * Throws while a wake for `from` is in flight.
+   */
+  migrate(from, to2) {
+    if (this.hasInFlight(from)) throw new Error(`A collaboration wake for ${from} is being delivered`);
+    this.db.prepare("UPDATE collaboration_wakes SET session_id = ? WHERE session_id = ?").run(to2, from);
+    this.db.prepare("DELETE FROM collaboration_wake_recipients WHERE session_id = ?").run(from);
+    this.paused.delete(from);
+    this.pause(to2);
+  }
   pause(sessionId) {
     if (this.paused.has(sessionId)) return;
     this.db.prepare(`INSERT INTO collaboration_wake_recipients (session_id, paused)
@@ -109204,6 +109647,7 @@ var CollaborationWakeQueue = class {
 // ../../packages/runtime/src/db/schema.ts
 var SCHEMA_SQL = `
 ${COLLABORATION_WAKE_TABLE_DDL}
+${SESSION_CONTINUATION_TABLE_DDL}
 PRAGMA foreign_keys = ON;
 
 CREATE TABLE IF NOT EXISTS meta (
@@ -111381,7 +111825,7 @@ function dispatchAutomationRpc(method, payload, ctx) {
 // ../../packages/runtime/src/server/rpc-codex.ts
 init_environment();
 init_oauth_loopback();
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 function invalid9(message) {
   throw Object.assign(new Error(message), { code: "invalid_argument" });
 }
@@ -111408,7 +111852,7 @@ async function startMcpOauth(client3, login) {
   const result3 = login((url2) => opened(url2));
   const first = await Promise.race([authorization, result3]);
   if (typeof first !== "string") return first;
-  const loginId = randomUUID17();
+  const loginId = randomUUID18();
   pendingMcpOauth.set(loginId, { clientSessionId: client3.clientSessionId, authorizationUrl: first, result: result3 });
   const forget = () => {
     setTimeout(() => pendingMcpOauth.delete(loginId), MCP_OAUTH_COLLECT_MS).unref?.();
@@ -112353,7 +112797,7 @@ var NodeTerminalManager = class {
 init_session();
 
 // ../../packages/runtime/src/lease/control-lease.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 var DEFAULT_TTL_MS = 3e4;
 var MAX_TTL_MS = 15 * 60 * 1e3;
 var YIELD_LEVEL = { none: 0, holder: 1, any: 2 };
@@ -112381,7 +112825,7 @@ function clampTtlMs(ttlMs) {
 var ControlLeaseService = class {
   constructor(db) {
     this.db = db;
-    this.leaseEpoch = randomUUID18();
+    this.leaseEpoch = randomUUID19();
   }
   db;
   leaseEpoch;
@@ -112468,7 +112912,7 @@ var ControlLeaseService = class {
         code: "failed_precondition"
       });
     }
-    const leaseId = randomUUID18();
+    const leaseId = randomUUID19();
     const generation = existing && existing.epoch === this.leaseEpoch ? String(Number(existing.generation || "0") + 1) : "1";
     const expiresAt = now + ttl;
     this.db.prepare(
@@ -112589,7 +113033,7 @@ import { dirname as dirname21, join as join51 } from "node:path";
 // ../../packages/runtime/src/mcp-apps/resource-store.ts
 init_mcp_apps();
 init_mcp_app_resource();
-import { createHash as createHash21, randomUUID as randomUUID19 } from "node:crypto";
+import { createHash as createHash21, randomUUID as randomUUID20 } from "node:crypto";
 import { existsSync as existsSync50, mkdirSync as mkdirSync25, readFileSync as readFileSync26, readdirSync as readdirSync16, renameSync as renameSync9, rmSync as rmSync11, statSync as statSync17, utimesSync, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join50 } from "node:path";
 function createMcpAppResourceStore(directory) {
@@ -112605,7 +113049,7 @@ function createMcpAppResourceStore(directory) {
       const hash2 = digest(snapshot.html), file2 = path(hash2);
       if (!existsSync50(file2) || statSync17(file2).size > MCP_APP_HTML_MAX_BYTES || digest(readFileSync26(file2, "utf8")) !== hash2) {
         mkdirSync25(directory, { recursive: true });
-        const temporary = join50(directory, `${hash2}.${randomUUID19()}.tmp`);
+        const temporary = join50(directory, `${hash2}.${randomUUID20()}.tmp`);
         try {
           writeFileSync20(temporary, snapshot.html, { encoding: "utf8", mode: 384, flag: "wx" });
           renameSync9(temporary, file2);
@@ -112685,15 +113129,23 @@ init_harness();
 // src/session/collaboration.ts
 init_environment();
 
-// ../../packages/runtime/src/collaboration/errors.ts
-var CollaborationError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "CollaborationError";
-  }
-  code;
-};
+// ../../packages/runtime/src/collaboration/continuation.ts
+function assertContinuable(store, wakes, from, state) {
+  if (!state) throw new CollaborationError(`Session ${from} no longer exists`, "not_found");
+  const successor = store.successorOf(from);
+  if (successor) throw new CollaborationError(`Session ${from} was already continued in ${successor}`, "failed_precondition");
+  if (state.busy || wakes.hasInFlight(from)) {
+    throw new CollaborationError(`Session ${from} is working; continue it once it is idle`, "failed_precondition");
+  }
+}
+function continueCollaboration(store, wakes, from, to2, state) {
+  return store.transaction(() => {
+    assertContinuable(store, wakes, from, state);
+    const moved = store.continueSession(from, to2);
+    wakes.migrate(from, to2);
+    return moved;
+  });
+}
 
 // ../../packages/runtime/src/collaboration/launch.ts
 init_agent_types();
@@ -112881,7 +113333,7 @@ function formatPeers(peers) {
 function resolveSendChannel(store, callerSessionId, to2, sessionTitle2) {
   const channels = listMailboxChannels(store, callerSessionId, sessionTitle2);
   const peers = peersOf(channels);
-  const target = to2?.trim();
+  const target = to2?.trim() ? store.currentSessionFor(to2.trim()) : void 0;
   if (!target) {
     if (peers.length === 0) throw new CollaborationError(NO_PEERS_HINT, "failed_precondition");
     const parent = channels.find((channel) => channel.peer.relation === "parent");
@@ -112915,7 +113367,7 @@ function normalizeMailboxContent(raw) {
 function readCallerMailbox(store, callerSessionId, options, sessionTitle2) {
   const channels = listMailboxChannels(store, callerSessionId, sessionTitle2);
   const peers = peersOf(channels);
-  const from = options.from?.map((id) => id.trim()).filter(Boolean) ?? [];
+  const from = options.from?.map((id) => id.trim()).filter(Boolean).map((id) => store.currentSessionFor(id)) ?? [];
   if (from.length > 0) {
     const known = new Set(peers.map((peer) => peer.sessionId));
     const unknown2 = from.filter((id) => !known.has(id));
@@ -113039,293 +113491,6 @@ function prepareLaunchStart(store, callerSessionId, input) {
   return { ...grant, task };
 }
 
-// ../../packages/runtime/src/collaboration/store.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
-var GRANT_COLUMNS = `credential_hash AS grant_id, parent_session_id, child_session_id,
-  agent_id, task, config_json, task_sent, COALESCE(kind, 'spawn') AS kind, started_at`;
-var MESSAGE_COLUMNS = `id, sequence, sender_session_id, recipient_session_id, client_message_id, content, created_at`;
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-var CollaborationStore = class {
-  constructor(db) {
-    this.db = db;
-  }
-  db;
-  transaction(fn) {
-    return this.db.transaction(fn)();
-  }
-  // --- grants --------------------------------------------------------------
-  grantById(grantId) {
-    return this.db.prepare(`SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants WHERE credential_hash = ?`).get(grantId) ?? null;
-  }
-  /**
-   * The grant an approved launch created. launchIds are agent-chosen and may
-   * repeat across requests, so the latest approval wins.
-   */
-  grantForLaunch(parentSessionId, launchId) {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE parent_session_id = ? AND json_extract(config_json, '$.launchId') = ?
-      ORDER BY created_at DESC, rowid DESC LIMIT 1
-    `).get(parentSessionId, launchId) ?? null;
-  }
-  /** True when `sessionId` is a spawn child (nested collaboration is unsupported). */
-  isSpawnChild(sessionId) {
-    return Boolean(this.db.prepare(`
-      SELECT 1 FROM session_collaboration_grants
-      WHERE child_session_id = ? AND COALESCE(kind, 'spawn') = 'spawn' LIMIT 1
-    `).get(sessionId));
-  }
-  spawnGrantForChild(childSessionId) {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE child_session_id = ? AND COALESCE(kind, 'spawn') = 'spawn'
-    `).get(childSessionId) ?? null;
-  }
-  startedSpawnGrants() {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE child_session_id IS NOT NULL AND COALESCE(kind, 'spawn') = 'spawn'
-    `).all();
-  }
-  /** Started handoff grants; the session each created is `config_json.handoffSessionId`. */
-  startedHandoffGrants() {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE kind = 'handoff' AND started_at IS NOT NULL
-    `).all();
-  }
-  /**
-   * Open mailbox channels of `sessionId`: spawn grants with a bound child and
-   * started link grants, oldest first. Handoff grants are never channels.
-   */
-  channelsFor(sessionId) {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE (parent_session_id = ? OR child_session_id = ?)
-        AND child_session_id IS NOT NULL
-        AND (COALESCE(kind, 'spawn') = 'spawn' OR (kind = 'link' AND started_at IS NOT NULL))
-      ORDER BY created_at, rowid
-    `).all(sessionId, sessionId);
-  }
-  /** True when one of the two sessions was created by a handoff from the other. */
-  isHandoffPair(a, b3) {
-    return Boolean(this.db.prepare(`
-      SELECT 1 FROM session_collaboration_grants
-      WHERE kind = 'handoff' AND (
-        (parent_session_id = ? AND json_extract(config_json, '$.handoffSessionId') = ?)
-        OR (parent_session_id = ? AND json_extract(config_json, '$.handoffSessionId') = ?)
-      ) LIMIT 1
-    `).get(a, b3, b3, a));
-  }
-  findLinkGrant(initiatorSessionId, peerSessionId) {
-    return this.db.prepare(`
-      SELECT ${GRANT_COLUMNS} FROM session_collaboration_grants
-      WHERE parent_session_id = ? AND child_session_id = ? AND kind = 'link'
-    `).get(initiatorSessionId, peerSessionId) ?? null;
-  }
-  /**
-   * Persist an approved launch. Link grants bind the peer at once; spawn and
-   * handoff grants bind their session on start. The brief arrives on start.
-   */
-  createGrant(input) {
-    const grantId = randomUUID20();
-    try {
-      this.db.prepare(`
-        INSERT INTO session_collaboration_grants
-          (credential_hash, credential_secret, credential_hint, parent_session_id, child_session_id,
-           agent_id, task, config_json, created_at, kind)
-        VALUES (?, NULL, '', ?, ?, ?, '', ?, ?, ?)
-      `).run(
-        grantId,
-        input.parentSessionId,
-        input.childSessionId ?? null,
-        input.agentId,
-        JSON.stringify(input.config),
-        nowIso(),
-        input.kind
-      );
-    } catch (error51) {
-      const message = error51 instanceof Error ? error51.message : String(error51);
-      if (input.childSessionId && /UNIQUE|unique/i.test(message)) {
-        throw new CollaborationError(
-          `Session ${input.parentSessionId} already has a link to ${input.childSessionId}; request it again to reuse it.`,
-          "failed_precondition"
-        );
-      }
-      throw error51;
-    }
-    return grantId;
-  }
-  updateConfig(grantId, config2) {
-    this.db.prepare("UPDATE session_collaboration_grants SET config_json = ? WHERE credential_hash = ?").run(JSON.stringify(config2), grantId);
-  }
-  /** Record the brief of a grant whose task has not been delivered yet. */
-  setTask(grantId, task) {
-    this.db.prepare("UPDATE session_collaboration_grants SET task = ? WHERE credential_hash = ? AND task_sent = 0").run(task, grantId);
-  }
-  markTaskSent(grantId) {
-    this.db.prepare("UPDATE session_collaboration_grants SET task_sent = 1 WHERE credential_hash = ?").run(grantId);
-  }
-  /** Link start. Returns false when the grant had already been started. */
-  markStarted(grantId) {
-    return this.db.prepare(`
-      UPDATE session_collaboration_grants SET started_at = ? WHERE credential_hash = ? AND started_at IS NULL
-    `).run(nowIso(), grantId).changes === 1;
-  }
-  /**
-   * Record the session a spawn/handoff start created. Throws when a concurrent
-   * start already consumed the grant.
-   *
-   * A handoff session is deliberately *not* written to child_session_id: that
-   * column holds channel endpoints (spawn children, link peers), and a handoff
-   * sibling is neither. The created id lives in config_json instead.
-   */
-  bindStartedSession(grant, sessionId, config2) {
-    const changes = grant.kind === "handoff" ? this.db.prepare(`
-          UPDATE session_collaboration_grants SET config_json = ?, started_at = ?
-          WHERE credential_hash = ? AND started_at IS NULL
-        `).run(JSON.stringify({ ...config2, handoffSessionId: sessionId }), nowIso(), grant.grant_id).changes : this.db.prepare(`
-          UPDATE session_collaboration_grants SET child_session_id = ?, started_at = ?
-          WHERE credential_hash = ? AND child_session_id IS NULL
-        `).run(sessionId, nowIso(), grant.grant_id).changes;
-    if (changes !== 1) throw new CollaborationError("This launch was already started", "failed_precondition");
-  }
-  // --- mailbox -------------------------------------------------------------
-  nextSequence(grantId) {
-    const row2 = this.db.prepare(`
-      SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence
-      FROM session_collaboration_messages WHERE credential_hash = ?
-    `).get(grantId);
-    return row2.next_sequence;
-  }
-  insertMessage(grantId, input) {
-    const row2 = {
-      id: randomUUID20(),
-      sequence: this.nextSequence(grantId),
-      sender_session_id: input.senderSessionId,
-      recipient_session_id: input.recipientSessionId,
-      client_message_id: input.clientMessageId,
-      content: input.content,
-      created_at: nowIso()
-    };
-    this.db.prepare(`
-      INSERT INTO session_collaboration_messages
-        (id, credential_hash, sequence, sender_session_id, recipient_session_id, client_message_id, content, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      row2.id,
-      grantId,
-      row2.sequence,
-      row2.sender_session_id,
-      row2.recipient_session_id,
-      row2.client_message_id,
-      row2.content,
-      row2.created_at
-    );
-    return row2;
-  }
-  /** Append one message; a repeated `clientMessageId` returns the stored row. */
-  appendMessage(input) {
-    return this.transaction(() => {
-      if (input.clientMessageId) {
-        const existing = this.db.prepare(`
-          SELECT ${MESSAGE_COLUMNS} FROM session_collaboration_messages
-          WHERE credential_hash = ? AND sender_session_id = ? AND client_message_id = ?
-        `).get(input.grantId, input.senderSessionId, input.clientMessageId);
-        if (existing) return { row: existing, reused: true };
-      }
-      const row2 = this.insertMessage(input.grantId, { ...input, clientMessageId: input.clientMessageId ?? null });
-      return { row: row2, reused: false };
-    });
-  }
-  /** When `sessionId` last sent and last received a mailbox message (ISO), across all its channels. */
-  lastMessageTimes(sessionId) {
-    return this.db.prepare(`
-      SELECT
-        (SELECT MAX(created_at) FROM session_collaboration_messages WHERE sender_session_id = ?) AS sentAt,
-        (SELECT MAX(created_at) FROM session_collaboration_messages WHERE recipient_session_id = ?) AS receivedAt
-    `).get(sessionId, sessionId);
-  }
-  /** Queue a link grant's opening body for the peer exactly once, then mark the task sent. */
-  appendLinkOpening(grant, recipientSessionId, content) {
-    this.transaction(() => {
-      try {
-        this.insertMessage(grant.grant_id, {
-          senderSessionId: grant.parent_session_id,
-          recipientSessionId,
-          clientMessageId: `link-opening:${grant.grant_id}`,
-          content
-        });
-      } catch {
-      }
-      this.markTaskSent(grant.grant_id);
-    });
-  }
-  /**
-   * Up to `limit` unread messages addressed to `sessionId` across grants,
-   * without marking them read: one per grant in turn, grants with the oldest
-   * unread message first, so successive reads reach every grant even when
-   * there are more grants than `limit`. Each batch is a prefix of its grant's
-   * unread messages. Selection reads only the mailbox index; bodies load for
-   * the selected messages alone.
-   */
-  peekMailbox(sessionId, grantIds, limit2) {
-    const unread = this.db.prepare(`
-      SELECT rowid AS rid FROM session_collaboration_messages
-      WHERE credential_hash = ? AND recipient_session_id = ? AND sequence > ?
-      ORDER BY sequence LIMIT ?
-    `);
-    const createdAt = this.db.prepare("SELECT created_at FROM session_collaboration_messages WHERE rowid = ?");
-    const queues2 = grantIds.flatMap((grantId) => {
-      const cursor = this.db.prepare(`
-        SELECT last_sequence FROM session_collaboration_cursors WHERE credential_hash = ? AND session_id = ?
-      `).get(grantId, sessionId);
-      const rids = unread.all(grantId, sessionId, cursor?.last_sequence ?? 0, limit2).map((row2) => row2.rid);
-      if (rids.length === 0) return [];
-      const oldest = createdAt.get(rids[0]).created_at;
-      return [{ grantId, rids, oldest, taken: 0 }];
-    }).sort((a, b3) => a.oldest.localeCompare(b3.oldest));
-    let budget = limit2;
-    while (budget > 0) {
-      let took = false;
-      for (const queue of queues2) {
-        if (budget === 0) break;
-        if (queue.taken === queue.rids.length) continue;
-        queue.taken++;
-        budget--;
-        took = true;
-      }
-      if (!took) break;
-    }
-    const load = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM session_collaboration_messages WHERE rowid = ?`);
-    return queues2.filter((queue) => queue.taken > 0).map(({ grantId, rids, taken }) => ({
-      grantId,
-      rows: rids.slice(0, taken).map((rid) => load.get(rid))
-    }));
-  }
-  /**
-   * Mark messages read up to each grant's `lastSequence`. A cursor never
-   * moves back, so acknowledgements may arrive in any order.
-   */
-  ackMailbox(sessionId, acks) {
-    this.transaction(() => {
-      for (const { grantId, lastSequence } of acks) {
-        this.db.prepare(`
-          INSERT INTO session_collaboration_cursors (credential_hash, session_id, last_sequence)
-          VALUES (?, ?, ?)
-          ON CONFLICT(credential_hash, session_id) DO UPDATE SET last_sequence = MAX(last_sequence, excluded.last_sequence)
-        `).run(grantId, sessionId, lastSequence);
-        this.db.prepare(`
-          UPDATE session_collaboration_messages SET delivered_at = COALESCE(delivered_at, ?)
-          WHERE credential_hash = ? AND recipient_session_id = ? AND sequence <= ?
-        `).run(nowIso(), grantId, sessionId, lastSequence);
-      }
-    });
-  }
-};
-
 // ../../packages/runtime/src/collaboration/index.ts
 init_text();
 
@@ -113393,6 +113558,7 @@ function retrieveCollaborationMessages(ctx, input) {
 init_agent_profile();
 init_environment();
 init_harness_capabilities();
+init_session_provider_definitions();
 
 // ../../packages/shared/src/acp-brand.ts
 init_acp_brand();
@@ -113468,7 +113634,7 @@ function listCollaborationProfiles(deps) {
       pushProfile(
         p3.id,
         p3.harnessId,
-        p3.name,
+        sessionProviderDisplayName(p3),
         p3.isBase ? `${p3.harnessId} harness with the built-in configuration` : `Custom ${p3.harnessId} profile`,
         p3.config
       );
@@ -113912,6 +114078,31 @@ var CollaborationService = class {
   retrieve(input) {
     return retrieveCollaborationMessages(this.ctx, input);
   }
+  /** The session `sessionId` was continued in; null when it was not. */
+  successorOf(sessionId) {
+    return this.ctx.store.successorOf(sessionId);
+  }
+  /** Throws when `from` cannot be continued in a new session now. */
+  assertContinuable(from) {
+    assertContinuable(this.ctx.store, this.ctx.wakes, from, this.continuedState(from));
+  }
+  /**
+   * `to` was just created to continue `from`: it takes over `from`'s channels
+   * and wakes, and the child prompt moves with a spawn grant.
+   */
+  continueSession(from, to2) {
+    continueCollaboration(this.ctx.store, this.ctx.wakes, from, to2, this.continuedState(from));
+    this.deps.sessions.moveExternalParent(from, to2);
+    const grant = this.ctx.store.spawnGrantForChild(to2);
+    if (grant) {
+      this.deps.sessions.setSystemPromptAppend(to2, launchedSessionPromptAppend(this.deps, grant));
+      this.deps.sessions.setSystemPromptAppend(from, null);
+    }
+  }
+  continuedState(sessionId) {
+    const session = this.deps.sessions.get(sessionId);
+    return session ? { busy: session.status === "streaming" || session.pendingInteraction != null } : null;
+  }
   /** Reconstruct the system-prompt append of launched sessions after restart (never link). */
   rehydrateSystemPrompts() {
     const launched = [