@layorixinc/axterm 0.5.0 → 0.6.0

package/dist/cli.js

@@ -46,6 +46,154 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/core/src/agent-registry.ts
+function agentProfile(id) {
+  const known = PROFILES[id];
+  if (known)
+    return known;
+  return {
+    id,
+    displayName: id,
+    title: {
+      workingLabel: id,
+      permissionLabel: `${id} - action required`,
+      idleLabel: `${id} ready`
+    },
+    hostHookSource: id
+  };
+}
+function renderAgentTitle(profile, state, frame) {
+  if (state === undefined)
+    return;
+  const { title } = profile;
+  if (state === "working") {
+    if (title.synthesizeWorking === false)
+      return;
+    const spinner = SPINNER_FRAMES[(frame % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length];
+    return `${spinner} ${title.workingLabel}`;
+  }
+  if (title.synthesizeTerminal === false)
+    return;
+  return state === "done" ? title.idleLabel : title.permissionLabel;
+}
+function oscTitle(title) {
+  const safe = title.replace(/[\x00-\x1f\x7f]/g, "").slice(0, MAX_TITLE_LENGTH);
+  return `\x1B]0;${safe}\x07`;
+}
+var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, REGISTERED_AGENTS, MAX_TITLE_LENGTH = 200;
+var init_agent_registry = __esm(() => {
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  PROFILES = {
+    omp: {
+      id: "omp",
+      displayName: "OMP",
+      title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
+      hostHookSource: "omp",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
+      quota: "gauge",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
+    },
+    pi: {
+      id: "pi",
+      displayName: "Pi",
+      title: { workingLabel: "Pi", permissionLabel: "Pi - action required", idleLabel: "Pi ready" },
+      hostHookSource: "pi",
+      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
+    },
+    codex: {
+      id: "codex",
+      displayName: "Codex",
+      title: {
+        workingLabel: "Codex",
+        permissionLabel: "Codex - action required",
+        idleLabel: "Codex ready",
+        synthesizeWorking: false
+      },
+      hostHookSource: "codex",
+      quota: "gauge",
+      approvalBypassArgs: ["--dangerously-bypass-approvals-and-sandbox"],
+      structuredApprovals: true,
+      resume: { argv: ["resume", "{ref}"], ref: "sessionId", form: "subcommand" }
+    },
+    opencode: {
+      id: "opencode",
+      displayName: "OpenCode",
+      title: {
+        workingLabel: "OpenCode",
+        permissionLabel: "OpenCode - action required",
+        idleLabel: "OpenCode ready",
+        synthesizeTerminal: false
+      },
+      hostHookSource: "opencode",
+      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
+    },
+    cursor: {
+      id: "cursor",
+      displayName: "Cursor Agent",
+      title: {
+        workingLabel: "Cursor Agent",
+        permissionLabel: "Cursor - action required",
+        idleLabel: "Cursor ready"
+      },
+      hostHookSource: "cursor",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
+    },
+    droid: {
+      id: "droid",
+      displayName: "Droid",
+      title: { workingLabel: "Droid", permissionLabel: "Droid - action required", idleLabel: "Droid ready" },
+      hostHookSource: "droid",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
+    },
+    claude: {
+      id: "claude",
+      displayName: "Claude Code",
+      title: {
+        workingLabel: "Claude",
+        permissionLabel: "Claude - action required",
+        idleLabel: "Claude ready",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
+      hostHookSource: "claude",
+      quota: "event",
+      approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId", selfNamed: "uuid" }
+    },
+    gemini: {
+      id: "gemini",
+      displayName: "Gemini CLI",
+      title: {
+        workingLabel: "Gemini",
+        permissionLabel: "Gemini - action required",
+        idleLabel: "Gemini ready",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
+      hostHookSource: "gemini",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
+      hookAck: "{}",
+      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId", selfNamed: "bare" }
+    }
+  };
+  REGISTERED_AGENTS = Object.keys(PROFILES);
+});
+
+// packages/core/src/session-id.ts
+function uuidFromSessionId(sessionId) {
+  const hex = sessionId.replace(/-/g, "");
+  if (hex.length !== 32)
+    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function sessionIdFromUuid(ref) {
+  if (!ref.includes("-"))
+    return;
+  const stripped = ref.replace(/-/g, "");
+  return /^[0-9a-f]{4,32}$/i.test(stripped) ? stripped.toLowerCase() : undefined;
+}
+
 // packages/core/src/mcp-config.ts
 function mcpServerEntry(launch, contextPath) {
   return {
@@ -76,18 +224,6 @@ function codexMcpArgs(launch, contextPath) {
 var MCP_SERVER_NAME = "axterm", MCP_CONTEXT_ENV = "AXTERM_MCP_CONTEXT";
 
 // packages/core/src/agent-launch.ts
-function uuidFromSessionId(sessionId) {
-  const hex = sessionId.replace(/-/g, "");
-  if (hex.length !== 32)
-    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function sessionIdFromUuid(ref) {
-  if (!ref.includes("-"))
-    return;
-  const stripped = ref.replace(/-/g, "");
-  return /^[0-9a-f]{4,32}$/i.test(stripped) ? stripped.toLowerCase() : undefined;
-}
 function withAppServer(argv, url) {
   const out = [];
   for (let i = 0;i < argv.length; i++) {
@@ -102,7 +238,13 @@ function withAppServer(argv, url) {
   return [out[0], "--remote", url, ...out.slice(1)];
 }
 function resumesAConversation(args) {
-  return args.some((arg) => CLAUDE_RESUME_FLAGS.has(arg) || arg.startsWith("--resume=") || arg.startsWith("--continue="));
+  return args.some((arg) => RESUME_FLAGS.has(arg) || arg.startsWith("--resume=") || arg.startsWith("--continue="));
+}
+function namingFlag(agent, sessionId, extra) {
+  const named = agentProfile(agent).resume?.selfNamed;
+  if (named === undefined || resumesAConversation(extra))
+    return [];
+  return ["--session-id", named === "uuid" ? uuidFromSessionId(sessionId) : sessionId];
 }
 function buildAgentCommand(input) {
   const extra = [...input.extraArgs ?? []];
@@ -112,17 +254,14 @@ function buildAgentCommand(input) {
       "--settings",
       input.claudeSettingsPath,
       ...input.mcpConfigPath === undefined ? [] : ["--mcp-config", input.mcpConfigPath],
-      "--session-id",
-      uuidFromSessionId(input.sessionId),
-      ...resumesAConversation(extra) ? ["--fork-session"] : [],
+      ...namingFlag("claude", input.sessionId, extra),
       ...extra
     ];
   }
   if (input.agent === "gemini") {
     return [
       "gemini",
-      "--session-id",
-      input.sessionId,
+      ...namingFlag("gemini", input.sessionId, extra),
       ...extra
     ];
   }
@@ -159,61 +298,16 @@ function resolveAgentArgs(input) {
   });
   return groups.filter((group, index) => group.flag === undefined || lastIndex.get(group.flag) === index).flatMap((group) => group.tokens);
 }
-function operatorArgsFrom(storedArgv) {
-  if (storedArgv === undefined || storedArgv.length === 0)
-    return [];
-  const kept = [];
-  for (let i = 1;i < storedArgv.length; i++) {
-    const token = storedArgv[i];
-    const width = AXTERM_OWNED_FLAGS[token];
-    if (width !== undefined) {
-      i += width - 1;
-      continue;
-    }
-    if (/^--(resume|continue)=/.test(token))
-      continue;
-    kept.push(token);
-  }
-  return kept;
-}
-function buildAgentResumeCommand(input) {
-  const operator = input.extraArgs ?? operatorArgsFrom(input.storedArgv);
-  if (input.agent === "claude") {
-    return [
-      "claude",
-      "--settings",
-      input.claudeSettingsPath,
-      ...input.mcpConfigPath === undefined ? [] : ["--mcp-config", input.mcpConfigPath],
-      ...operator,
-      "--resume",
-      uuidFromSessionId(input.sessionId)
-    ];
-  }
-  if (input.agent === "gemini") {
-    return ["gemini", ...operator, "--resume", input.sessionId];
-  }
-  return buildAgentCommand({ ...input, extraArgs: operator });
-}
 function isAgentId(value) {
   return AGENT_IDS.includes(value);
 }
 function supportedAgents() {
   return AGENT_IDS;
 }
-var CLAUDE_RESUME_FLAGS, AXTERM_OWNED_FLAGS, AGENT_IDS;
+var RESUME_FLAGS, AGENT_IDS;
 var init_agent_launch = __esm(() => {
-  CLAUDE_RESUME_FLAGS = new Set(["--resume", "-r", "--continue", "-c"]);
-  AXTERM_OWNED_FLAGS = {
-    "--settings": 2,
-    "--mcp-config": 2,
-    "--session-id": 2,
-    "--extension": 2,
-    "--fork-session": 1,
-    "--resume": 2,
-    "-r": 2,
-    "--continue": 1,
-    "-c": 1
-  };
+  init_agent_registry();
+  RESUME_FLAGS = new Set(["--resume", "-r", "--continue", "-c"]);
   AGENT_IDS = ["omp", "claude", "codex", "gemini"];
 });
 
@@ -944,6 +1038,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.session.sent": "sent",
     "cli.session.sentKey": "sent {key}",
     "cli.session.selected": "selected option {index}",
+    "cli.session.selectedDialog": "answered the agent's first-run dialog",
     "cli.resume.done": "resumed session {id} ({command})",
     "cli.update.current": "axterm {version} is the latest version",
     "cli.update.available": "axterm {latest} is available (you have {current})",
@@ -1013,7 +1108,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "err.telegram.noToken": "no bot token is configured \u2014 run `axterm setup` or pass --token",
     "tg.help.general.header": "axterm commands (General topic):",
     "tg.help.general.projects": "/projects \u2014 registered projects",
-    "tg.help.general.new": "/new <project> [name] \u2014 new omp session",
+    "tg.help.general.new": "/new <project> [name] [-- agent flags] \u2014 new session (e.g. --resume <conversation>)",
     "tg.help.general.wt": "/wt <project> <branch> \u2014 worktree session",
     "tg.help.general.fanout": "/fanout <project> <count|branches> <prompt> \u2014 run in parallel",
     "tg.help.general.worktrees": "/worktrees <project> \xB7 /rm <project> <branch> [force]",
@@ -1035,6 +1130,9 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.prompt.confirm": "the session is waiting on a confirmation:",
     "tg.prompt.secretAsk": "the session is asking for a secret. Reply with it and the message will be deleted:",
     "tg.prompt.secretDisabled": "the session is waiting for a password. Answering from chat is off (channels.telegram.secretPrompts); attach and type it, or use an SSH key",
+    "tg.prompt.secretSubmitted": "the secret reached the session",
+    "tg.prompt.secretStale": "that prompt is no longer waiting, so nothing was typed into the session",
+    "tg.prompt.secretUndeleted": "\u26A0\uFE0F Telegram refused to delete that message \u2014 the secret is still in the chat; delete it yourself",
     "tg.session.screenFile": "terminal screen",
     "tg.session.none": "no sessions",
     "tg.prompt.failed": "\u26A0\uFE0F Delivery failed: {error}",
@@ -1154,6 +1252,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.agent.unknown": "unknown agent '{agent}' \u2014 supported: {supported}",
     "err.staging.dir": "could not create the session's staging directory {dir} ({error}) \u2014 fix the permissions, or set defaults.staging to runtime",
     "err.staging.notIgnored": "git can see inside {dir}, so a staged file would show up in `git add -A` \u2014 let axterm write its own {file}, or set defaults.staging to runtime",
+    "err.claude.conversationBusy": "session {session} is already in conversation {id} \u2014 two sessions writing one transcript would corrupt it; kill that one first",
     "err.claude.noConversation": "claude has no conversation {id} in its store on this machine \u2014 a conversation lives on the machine it ran on, so this one cannot be resumed here",
     "codex.approval.denied": "Denied from the axterm channel",
     "err.codex.noAuth": "codex is not logged in ({authFile} not found) \u2014 run `codex login` once, then start the session again",
@@ -1245,6 +1344,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.session.sent": "\uC804\uB2EC\uB428",
     "cli.session.sentKey": "{key} \uC804\uB2EC\uB428",
     "cli.session.selected": "{index}\uBC88 \uD56D\uBAA9 \uC120\uD0DD\uB428",
+    "cli.session.selectedDialog": "\uC5D0\uC774\uC804\uD2B8\uC758 \uCCAB \uC2E4\uD589 \uB300\uD654\uC0C1\uC790\uC5D0 \uC751\uB2F5\uD588\uC2B5\uB2C8\uB2E4",
     "cli.resume.done": "\uC138\uC158 {id} \uC7AC\uAC1C\uB428 ({command})",
     "cli.update.current": "axterm {version} \uC774 \uCD5C\uC2E0 \uBC84\uC804\uC785\uB2C8\uB2E4",
     "cli.update.available": "axterm {latest} \uC744(\uB97C) \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4 (\uD604\uC7AC {current})",
@@ -1307,7 +1407,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.telegram.missingSettings": "telegram link: \uD1A0\uD070/\uADF8\uB8F9/\uC0AC\uC6A9\uC790 \uC815\uBCF4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. --token/--group/--user \uD50C\uB798\uADF8, TELEGRAM_* \uD658\uACBD\uBCC0\uC218, \uB610\uB294 \uD604\uC7AC \uD3F4\uB354\uC758 .env \uD30C\uC77C \uC911 \uD558\uB098\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.",
     "tg.help.general.header": "axterm \uBA85\uB839 (General \uD1A0\uD53D):",
     "tg.help.general.projects": "/projects \u2014 \uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8",
-    "tg.help.general.new": "/new <\uD504\uB85C\uC81D\uD2B8> [\uC774\uB984] \u2014 \uC0C8 omp \uC138\uC158",
+    "tg.help.general.new": "/new <\uD504\uB85C\uC81D\uD2B8> [\uC774\uB984] [\uC5D0\uC774\uC804\uD2B8 \uD50C\uB798\uADF8] \u2014 \uC0C8 \uC138\uC158 (\uC608: --resume <\uB300\uD654>)",
     "tg.help.general.wt": "/wt <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> \u2014 worktree \uC138\uC158",
     "tg.help.general.fanout": "/fanout <\uD504\uB85C\uC81D\uD2B8> <\uAC1C\uC218|\uBE0C\uB79C\uCE58\uB4E4> <\uD504\uB86C\uD504\uD2B8> \u2014 \uBCD1\uB82C \uC2E4\uD589",
     "tg.help.general.worktrees": "/worktrees <\uD504\uB85C\uC81D\uD2B8> \xB7 /rm <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> [force]",
@@ -1336,6 +1436,9 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.prompt.confirm": "\uC138\uC158\uC774 \uD655\uC778\uC744 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4:",
     "tg.prompt.secretAsk": "\uC138\uC158\uC774 \uBE44\uBC00\uAC12\uC744 \uC694\uAD6C\uD569\uB2C8\uB2E4. \uB2F5\uC7A5\uD558\uBA74 \uADF8 \uBA54\uC2DC\uC9C0\uB294 \uC0AD\uC81C\uB429\uB2C8\uB2E4:",
     "tg.prompt.secretDisabled": "\uC138\uC158\uC774 \uBE44\uBC00\uBC88\uD638\uB97C \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4. \uCC44\uD305 \uC785\uB825\uC740 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4 (channels.telegram.secretPrompts). attach \uD574\uC11C \uC785\uB825\uD558\uAC70\uB098 SSH \uD0A4\uB97C \uC4F0\uC138\uC694",
+    "tg.prompt.secretSubmitted": "\uBE44\uBC00\uAC12\uC774 \uC138\uC158\uC5D0 \uC804\uB2EC\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+    "tg.prompt.secretStale": "\uADF8 \uD504\uB86C\uD504\uD2B8\uB294 \uB354 \uC774\uC0C1 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC9C0 \uC54A\uC544 \uC138\uC158\uC5D0 \uC544\uBB34\uAC83\uB3C4 \uC785\uB825\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4",
+    "tg.prompt.secretUndeleted": "\u26A0\uFE0F Telegram\uC774 \uBA54\uC2DC\uC9C0 \uC0AD\uC81C\uB97C \uAC70\uBD80\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uBE44\uBC00\uAC12\uC774 \uC544\uC9C1 \uCC44\uD305\uC5D0 \uB0A8\uC544 \uC788\uC2B5\uB2C8\uB2E4. \uC9C1\uC811 \uC0AD\uC81C\uD558\uC138\uC694",
     "tg.session.screenFile": "\uD130\uBBF8\uB110 \uD654\uBA74",
     "tg.session.none": "\uC138\uC158 \uC5C6\uC74C",
     "tg.prompt.failed": "\u26A0\uFE0F \uC804\uB2EC \uC2E4\uD328: {error}",
@@ -1455,6 +1558,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.agent.unknown": "\uC54C \uC218 \uC5C6\uB294 \uC5D0\uC774\uC804\uD2B8 '{agent}' \uC785\uB2C8\uB2E4. \uC9C0\uC6D0: {supported}",
     "err.staging.dir": "\uC138\uC158\uC758 \uC2A4\uD14C\uC774\uC9D5 \uB514\uB809\uD130\uB9AC {dir} \uC744(\uB97C) \uB9CC\uB4E4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 ({error}). \uAD8C\uD55C\uC744 \uACE0\uCE58\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
     "err.staging.notIgnored": "git\uC774 {dir} \uC548\uC744 \uBCFC \uC218 \uC788\uC5B4\uC11C, \uC2A4\uD14C\uC774\uC9D5\uD55C \uD30C\uC77C\uC774 `git add -A` \uC5D0 \uC7A1\uD799\uB2C8\uB2E4. axterm\uC774 \uC790\uCCB4 {file} \uC744(\uB97C) \uC4F0\uAC8C \uD558\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
+    "err.claude.conversationBusy": "\uC138\uC158 {session} \uC774(\uAC00) \uC774\uBBF8 \uB300\uD654 {id} \uC5D0 \uB4E4\uC5B4\uAC00 \uC788\uC2B5\uB2C8\uB2E4. \uD55C transcript\uC5D0 \uB450 \uC138\uC158\uC774 \uC4F0\uBA74 \uC190\uC0C1\uB418\uBBC0\uB85C \uBA3C\uC800 \uADF8 \uC138\uC158\uC744 \uC885\uB8CC\uD558\uC138\uC694",
     "err.claude.noConversation": "\uC774 \uBA38\uC2E0\uC758 claude \uC800\uC7A5\uC18C\uC5D0 \uB300\uD654 {id} \uC774(\uAC00) \uC5C6\uC2B5\uB2C8\uB2E4. \uB300\uD654\uB294 \uC2E4\uD589\uB41C \uBA38\uC2E0\uC5D0 \uB0A8\uC73C\uBBC0\uB85C \uC5EC\uAE30\uC11C\uB294 \uC774\uC5B4\uAC08 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
     "codex.approval.denied": "axterm \uCC44\uB110\uC5D0\uC11C \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
     "err.codex.noAuth": "codex\uC5D0 \uB85C\uADF8\uC778\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 ({authFile} \uC5C6\uC74C). `codex login` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD55C \uB4A4 \uC138\uC158\uC744 \uB2E4\uC2DC \uC2DC\uC791\uD558\uC138\uC694",
@@ -1645,144 +1749,16 @@ var init_setup_wizard = __esm(() => {
   wizardConfig = new WeakMap;
 });
 
-// packages/core/src/agent-registry.ts
-function agentProfile(id) {
-  const known = PROFILES[id];
-  if (known)
-    return known;
-  return {
-    id,
-    displayName: id,
-    title: {
-      workingLabel: id,
-      permissionLabel: `${id} - action required`,
-      idleLabel: `${id} ready`
-    },
-    hostHookSource: id
-  };
-}
-function renderAgentTitle(profile, state, frame) {
-  if (state === undefined)
-    return;
-  const { title } = profile;
-  if (state === "working") {
-    if (title.synthesizeWorking === false)
-      return;
-    const spinner = SPINNER_FRAMES[(frame % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length];
-    return `${spinner} ${title.workingLabel}`;
-  }
-  if (title.synthesizeTerminal === false)
-    return;
-  return state === "done" ? title.idleLabel : title.permissionLabel;
-}
-function oscTitle(title) {
-  const safe = title.replace(/[\x00-\x1f\x7f]/g, "").slice(0, MAX_TITLE_LENGTH);
-  return `\x1B]0;${safe}\x07`;
-}
-var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, REGISTERED_AGENTS, MAX_TITLE_LENGTH = 200;
-var init_agent_registry = __esm(() => {
-  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  PROFILES = {
-    omp: {
-      id: "omp",
-      displayName: "OMP",
-      title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
-      hostHookSource: "omp",
-      approvalBypassArgs: ["--approval-mode", "yolo"],
-      quota: "gauge",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
-    },
-    pi: {
-      id: "pi",
-      displayName: "Pi",
-      title: { workingLabel: "Pi", permissionLabel: "Pi - action required", idleLabel: "Pi ready" },
-      hostHookSource: "pi",
-      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
-    },
-    codex: {
-      id: "codex",
-      displayName: "Codex",
-      title: {
-        workingLabel: "Codex",
-        permissionLabel: "Codex - action required",
-        idleLabel: "Codex ready",
-        synthesizeWorking: false
-      },
-      hostHookSource: "codex",
-      quota: "gauge",
-      approvalBypassArgs: ["--dangerously-bypass-approvals-and-sandbox"],
-      structuredApprovals: true,
-      resume: { argv: ["resume", "{ref}"], ref: "sessionId", form: "subcommand" }
-    },
-    opencode: {
-      id: "opencode",
-      displayName: "OpenCode",
-      title: {
-        workingLabel: "OpenCode",
-        permissionLabel: "OpenCode - action required",
-        idleLabel: "OpenCode ready",
-        synthesizeTerminal: false
-      },
-      hostHookSource: "opencode",
-      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
-    },
-    cursor: {
-      id: "cursor",
-      displayName: "Cursor Agent",
-      title: {
-        workingLabel: "Cursor Agent",
-        permissionLabel: "Cursor - action required",
-        idleLabel: "Cursor ready"
-      },
-      hostHookSource: "cursor",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    droid: {
-      id: "droid",
-      displayName: "Droid",
-      title: { workingLabel: "Droid", permissionLabel: "Droid - action required", idleLabel: "Droid ready" },
-      hostHookSource: "droid",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    claude: {
-      id: "claude",
-      displayName: "Claude Code",
-      title: {
-        workingLabel: "Claude",
-        permissionLabel: "Claude - action required",
-        idleLabel: "Claude ready",
-        synthesizeWorking: false,
-        synthesizeTerminal: false
-      },
-      hostHookSource: "claude",
-      quota: "event",
-      approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    gemini: {
-      id: "gemini",
-      displayName: "Gemini CLI",
-      title: {
-        workingLabel: "Gemini",
-        permissionLabel: "Gemini - action required",
-        idleLabel: "Gemini ready",
-        synthesizeWorking: false,
-        synthesizeTerminal: false
-      },
-      hostHookSource: "gemini",
-      approvalBypassArgs: ["--approval-mode", "yolo"],
-      hookAck: "{}",
-      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    }
-  };
-  REGISTERED_AGENTS = Object.keys(PROFILES);
-});
-
 // packages/core/src/agent-resume.ts
 function resumeReference(profile, source) {
-  const value = profile.resume?.ref === "sessionId" ? source.agentSessionId : source.agentSessionFile;
-  return value !== undefined && value.length > 0 ? value : undefined;
+  const reported = profile.resume?.ref === "sessionId" ? source.agentSessionId : source.agentSessionFile;
+  if (reported !== undefined && reported.length > 0)
+    return reported;
+  const named = profile.resume?.selfNamed;
+  const own = source.ownSessionId;
+  if (named === undefined || own === undefined || own.length === 0)
+    return;
+  return named === "uuid" ? uuidFromSessionId(own) : own;
 }
 function agentIdFromCommand(command) {
   const head = command[0] ?? "";
@@ -1809,17 +1785,23 @@ function withoutExistingResume(command, fragment) {
   }
   return command;
 }
+function withoutNamingFlag(command) {
+  const at = command.indexOf("--session-id");
+  return at < 0 ? command : [...command.slice(0, at), ...command.slice(at + 2)];
+}
 function buildResumeCommand(command, profile, reference) {
   const resume = profile.resume;
   const binary = command[0];
   if (!resume || binary === undefined || reference.length === 0)
     return;
   const template = resume.argv;
-  const base = withoutExistingResume(command, template);
+  const stripped = withoutExistingResume(command, template);
+  const base = resume.selfNamed === undefined ? stripped : withoutNamingFlag(stripped);
   const fragment = template.map((token) => token.replaceAll(REF, reference));
   return resume.form === "subcommand" ? [base[0], ...fragment, ...base.slice(1)] : [...base, ...fragment];
 }
 var REF = "{ref}";
+var init_agent_resume = () => {};
 
 // packages/core/src/self-spawn.ts
 function daemonLaunch(input) {
@@ -1848,9 +1830,9 @@ function ptyHostLaunch(input) {
 function isPtyHostInvocation(args) {
   return args[0] === PTY_HOST_ARGV_FLAG;
 }
-function hookPostTarget(env, agent) {
-  const port = Number(env["AXTERM_HOOK_PORT"]);
-  const token = env["AXTERM_HOOK_TOKEN"];
+function hookPostTarget(env, agent, override) {
+  const port = override?.port ?? Number(env["AXTERM_HOOK_PORT"]);
+  const token = override?.token ?? env["AXTERM_HOOK_TOKEN"];
   const sessionId = env["AXTERM_SESSION_ID"];
   const launchToken = env["AXTERM_LAUNCH_TOKEN"];
   if (!Number.isSafeInteger(port) || port <= 0)
@@ -1867,6 +1849,13 @@ function hookPostTarget(env, agent) {
     }
   };
 }
+function parseHookEndpoint(text) {
+  const port = Number(/^AXTERM_HOOK_PORT=(\d+)$/m.exec(text)?.[1]);
+  const token = /^AXTERM_HOOK_TOKEN=(\S+)$/m.exec(text)?.[1];
+  if (!Number.isSafeInteger(port) || port <= 0 || !token)
+    return;
+  return { port, token };
+}
 function isDaemonInvocation(args) {
   return args[0] === DAEMON_ARGV_FLAG;
 }
@@ -1992,6 +1981,7 @@ function planUpdateRestart(input) {
 var SEMVER;
 var init_update = __esm(() => {
   init_agent_registry();
+  init_agent_resume();
   SEMVER = /^\d+\.\d+\.\d+/;
 });
 
@@ -2192,6 +2182,30 @@ function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
 }
 var MENU_UP = "\x1B[A", MENU_DOWN = "\x1B[B", MENU_SELECT = "\r", MENU_NORMALIZE_PRESSES = 24;
 
+// packages/core/src/adopt.ts
+function resolveSessionCwd(input) {
+  if (!input.preferConversation)
+    return input.requested;
+  const own = input.conversationCwd;
+  return own !== undefined && own.length > 0 ? own : input.requested;
+}
+function conversationHeldBy(sessions, conversationId) {
+  if (conversationId.length === 0)
+    return;
+  return sessions.find((session) => {
+    if (session.state !== "running")
+      return false;
+    if (session.agentSessionId === conversationId)
+      return true;
+    const argv = session.agentCommand;
+    return argv.some((token, index) => {
+      if (token === "--resume" || token === "-r" || token === "--session-id")
+        return argv[index + 1] === conversationId;
+      return token === `--resume=${conversationId}`;
+    });
+  });
+}
+
 // packages/core/src/agent-status.ts
 function next(prev, state, now) {
   return {
@@ -2201,17 +2215,29 @@ function next(prev, state, now) {
     stateStartedAt: prev?.state === state ? prev.stateStartedAt : now
   };
 }
-function reduceAgentState(prev, payload, now) {
+function withConversationId(events, identity) {
+  const id = identity.sessionId;
+  const subagent = identity.subagentId;
+  if (typeof id !== "string" || id === "" || typeof subagent === "string" && subagent !== "") {
+    return [...events];
+  }
+  return events.map((event) => ({ session_id: id, ...event }));
+}
+function reduceAgentState(prev, payload, now) {
+  const result = reduceState(prev, payload, now);
+  const identity = {
+    ...payload.session_id !== undefined ? { agentSessionId: payload.session_id } : {},
+    ...payload.session_file !== undefined ? { agentSessionFile: payload.session_file } : {},
+    ...payload.session_name !== undefined ? { sessionName: payload.session_name } : {}
+  };
+  if (Object.keys(identity).length === 0)
+    return result;
+  return { ...result, meta: { ...identity, ...result.meta } };
+}
+function reduceState(prev, payload, now) {
   switch (payload.event) {
     case "session_start":
-      return {
-        entry: prev,
-        meta: {
-          agentSessionId: payload.session_id,
-          agentSessionFile: payload.session_file,
-          sessionName: payload.session_name
-        }
-      };
+      return { entry: prev };
     case "before_agent_start": {
       const entry = next(prev, prev?.state ?? "working", now);
       entry.prompt = payload.prompt ?? "";
@@ -2378,7 +2404,18 @@ var init_pty_protocol = __esm(() => {
     Data: 2
   };
   MAX_FRAME_BYTES = 8 * 1024 * 1024;
-  KNOWN_TYPES = new Set(["hello", "spawn", "resize", "kill", "welcome", "spawned", "exit", "error"]);
+  KNOWN_TYPES = new Set([
+    "hello",
+    "spawn",
+    "subscribe",
+    "resize",
+    "kill",
+    "welcome",
+    "spawned",
+    "subscribed",
+    "exit",
+    "error"
+  ]);
 });
 
 // packages/core/src/workspace.ts
@@ -2573,6 +2610,8 @@ var init_onboarding = __esm(() => {
       { kind: "authMethod", question: "How would you like to authenticate for this project?" }
     ],
     claude: [
+      { kind: "folderTrust", question: "Quick safety check: Is this a project you created or one you trust?" },
+      { kind: "autoMode", question: "Set up auto mode for your environment?" },
       { kind: "apiKey", question: "Do you want to use this API key?" },
       { kind: "loginMethod", question: "Select login method:" }
     ],
@@ -3614,6 +3653,9 @@ function sessionsByRecency(live, stored) {
 var asGiven = (target) => target;
 var init_session_scope = () => {};
 
+// packages/core/src/test-scratch.ts
+var init_test_scratch = () => {};
+
 // packages/core/src/index.ts
 function isRpcEvent(f) {
   return typeof f.ev === "string";
@@ -3633,6 +3675,7 @@ var init_src = __esm(() => {
   init_config_paths();
   init_setup_wizard();
   init_agent_registry();
+  init_agent_resume();
   init_self_spawn();
   init_channel_spi();
   init_update();
@@ -3660,19 +3703,20 @@ var init_src = __esm(() => {
   init_dotenv_scrub();
   init_prompt_detect();
   init_session_scope();
+  init_test_scratch();
   SUBMIT_DELAY_MS = process.platform === "win32" ? 1500 : 500;
   PASTE_CHUNK_BYTES = 16 * 1024;
 });
 
 // packages/daemon/src/config-store.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path6 from "path";
 function writeAtomic(target, contents, mode) {
   const tmp = `${target}.tmp`;
-  fs5.writeFileSync(tmp, contents, { mode });
-  fs5.renameSync(tmp, target);
+  fs6.writeFileSync(tmp, contents, { mode });
+  fs6.renameSync(tmp, target);
   if (process.platform !== "win32")
-    fs5.chmodSync(target, mode);
+    fs6.chmodSync(target, mode);
 }
 
 class ConfigStore {
@@ -3688,16 +3732,16 @@ class ConfigStore {
   }
   load() {
     this.loadError = undefined;
-    fs5.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
+    fs6.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
     if (process.platform !== "win32") {
       try {
-        fs5.chmodSync(this.paths.configDir, DIR_MODE);
+        fs6.chmodSync(this.paths.configDir, DIR_MODE);
       } catch {}
     }
     this.config = structuredClone(DEFAULT_CONFIG);
-    if (fs5.existsSync(this.paths.configFile)) {
+    if (fs6.existsSync(this.paths.configFile)) {
       try {
-        const parsed = parseConfig(JSON.parse(fs5.readFileSync(this.paths.configFile, "utf8")));
+        const parsed = parseConfig(JSON.parse(fs6.readFileSync(this.paths.configFile, "utf8")));
         if ("errors" in parsed)
           this.loadError = parsed.errors.join("; ");
         else
@@ -3707,10 +3751,10 @@ class ConfigStore {
       }
     }
     this.secrets = {};
-    if (fs5.existsSync(this.paths.secretsFile)) {
+    if (fs6.existsSync(this.paths.secretsFile)) {
       this.tightenPermissions(this.paths.secretsFile);
       try {
-        const raw = JSON.parse(fs5.readFileSync(this.paths.secretsFile, "utf8"));
+        const raw = JSON.parse(fs6.readFileSync(this.paths.secretsFile, "utf8"));
         if (raw !== null && typeof raw === "object") {
           for (const [key, value] of Object.entries(raw)) {
             if (typeof value === "string")
@@ -3726,8 +3770,8 @@ class ConfigStore {
     if (process.platform === "win32")
       return;
     try {
-      if ((fs5.statSync(file).mode & 63) !== 0)
-        fs5.chmodSync(file, FILE_MODE);
+      if ((fs6.statSync(file).mode & 63) !== 0)
+        fs6.chmodSync(file, FILE_MODE);
     } catch {}
   }
   get() {
@@ -3735,7 +3779,7 @@ class ConfigStore {
   }
   health() {
     return configHealth({
-      fileExists: fs5.existsSync(this.paths.configFile),
+      fileExists: fs6.existsSync(this.paths.configFile),
       parseError: this.loadError,
       config: this.resolved()
     });
@@ -3780,7 +3824,7 @@ class ConfigStore {
       delete this.secrets[dottedPath];
     else
       this.secrets[dottedPath] = value;
-    if (!fs5.existsSync(this.paths.configFile)) {
+    if (!fs6.existsSync(this.paths.configFile)) {
       writeAtomic(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
 `, FILE_MODE);
     }
@@ -3810,7 +3854,7 @@ class ConfigStore {
   fingerprint() {
     const stamp = (file) => {
       try {
-        return String(fs5.statSync(file).mtimeMs);
+        return String(fs6.statSync(file).mtimeMs);
       } catch {
         return "-";
       }
@@ -3852,7 +3896,7 @@ var init_config_store = __esm(() => {
 });
 
 // packages/daemon/src/shell.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 function findExecutable(name, env) {
   const isWindows = env.platform === "win32";
@@ -3876,7 +3920,7 @@ function lookupOnPath(name) {
     platform: process.platform,
     pathEnv: process.env["PATH"] ?? "",
     pathExt: process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD",
-    exists: (candidate) => fs6.existsSync(candidate)
+    exists: (candidate) => fs7.existsSync(candidate)
   });
 }
 function resolveShell(kind) {
@@ -3913,7 +3957,7 @@ function resolvePosixShell(kind) {
       candidates.push({ kind: "bash", exe: login });
     candidates.push({ kind: "bash", exe: "/bin/bash" }, { kind: "bash", exe: "/usr/bin/bash" });
   }
-  const found = candidates.find((c) => fs6.existsSync(c.exe));
+  const found = candidates.find((c) => fs7.existsSync(c.exe));
   if (found)
     return found;
   return { kind: "sh", exe: "/bin/sh" };
@@ -3964,18 +4008,18 @@ var cachedPwsh;
 var init_shell = () => {};
 
 // packages/daemon/src/paths.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os3 from "os";
 import path8 from "path";
 function ensureDataDirs() {
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir, SCROLLBACK_DIR, LOG_DIR, EXT_DIR]) {
-    fs7.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
+    fs8.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
   }
   if (process.platform === "win32")
     return;
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir]) {
     try {
-      fs7.chmodSync(dir, DIR_MODE2);
+      fs8.chmodSync(dir, DIR_MODE2);
     } catch {}
   }
 }
@@ -3983,14 +4027,14 @@ function restrictFile(file) {
   if (process.platform === "win32")
     return;
   try {
-    fs7.chmodSync(file, 384);
+    fs8.chmodSync(file, 384);
   } catch {}
 }
 function log(message) {
   const line = `${new Date().toISOString()} ${message}
 `;
   try {
-    fs7.appendFileSync(LOG_FILE, line);
+    fs8.appendFileSync(LOG_FILE, line);
   } catch {}
 }
 var PATHS, CONFIG_DIR, STATE_DIR, RUNTIME_DIR, SCROLLBACK_DIR, LOG_DIR, EXT_DIR, DB_PATH, RUNTIME_FILE2, HOOK_ENDPOINT_FILE, DIR_MODE2 = 448, PIPE_PATH, LOG_FILE;
@@ -4014,7 +4058,7 @@ var init_paths = __esm(() => {
 });
 
 // packages/daemon/src/store.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 import { Database } from "bun:sqlite";
 function rowToInfo(row) {
@@ -4046,7 +4090,7 @@ function rowToInfo(row) {
 class Store {
   db;
   constructor(dbPath = DB_PATH) {
-    fs8.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    fs9.mkdirSync(path9.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath, { strict: true });
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`
@@ -4125,8 +4169,10 @@ class Store {
     this.db.prepare(`UPDATE sessions SET state = 'running', exit_code = NULL, exited_at = NULL,
                              agent_command = ?, pty_pid = ? WHERE id = ?`).run(JSON.stringify(agentCommand), ptyPid ?? null, id);
   }
-  markStaleRunningAsExited() {
-    return this.db.prepare(`UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited'`).run(Date.now()).changes;
+  markStaleRunningAsExited(keep = []) {
+    const holes = keep.map(() => "?").join(",");
+    const sql = keep.length === 0 ? `UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited'` : `UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited' AND id NOT IN (${holes})`;
+    return this.db.prepare(sql).run(Date.now(), ...keep).changes;
   }
   listSessions() {
     const rows = this.db.prepare(`SELECT * FROM sessions ORDER BY created_at DESC`).all();
@@ -4212,11 +4258,11 @@ var init_store = __esm(() => {
 });
 
 // packages/daemon/src/config-migrate.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 import { Database as Database2 } from "bun:sqlite";
 function checkpointWal(dbFile) {
-  if (!fs9.existsSync(dbFile))
+  if (!fs10.existsSync(dbFile))
     return;
   try {
     const db = new Database2(dbFile);
@@ -4226,30 +4272,30 @@ function checkpointWal(dbFile) {
 }
 function relocate(source, target) {
   try {
-    fs9.renameSync(source, target);
+    fs10.renameSync(source, target);
   } catch {
-    fs9.cpSync(source, target, { recursive: true });
+    fs10.cpSync(source, target, { recursive: true });
   }
 }
 function moveInto(from, to, notes) {
   checkpointWal(path10.join(from, "axterm.db"));
-  fs9.mkdirSync(to, { recursive: true });
+  fs10.mkdirSync(to, { recursive: true });
   for (const entry of STATE_ENTRIES) {
     const source = path10.join(from, entry);
     const target = path10.join(to, entry);
-    if (!fs9.existsSync(source))
+    if (!fs10.existsSync(source))
       continue;
-    if (!fs9.existsSync(target)) {
+    if (!fs10.existsSync(target)) {
       relocate(source, target);
       notes.push(`moved ${entry}`);
       continue;
     }
-    if (!fs9.statSync(source).isDirectory() || !fs9.statSync(target).isDirectory())
+    if (!fs10.statSync(source).isDirectory() || !fs10.statSync(target).isDirectory())
       continue;
     let moved = 0;
-    for (const child of fs9.readdirSync(source)) {
+    for (const child of fs10.readdirSync(source)) {
       const childTarget = path10.join(target, child);
-      if (fs9.existsSync(childTarget))
+      if (fs10.existsSync(childTarget))
         continue;
       relocate(path10.join(source, child), childTarget);
       moved += 1;
@@ -4261,29 +4307,29 @@ function moveInto(from, to, notes) {
 function migrateLegacyConfig(input) {
   const notes = [];
   const storePaths = defaultConfigStorePaths(input.configDir);
-  if (fs9.existsSync(storePaths.configFile))
+  if (fs10.existsSync(storePaths.configFile))
     return { migrated: false, notes };
-  const configSource = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "config.json")));
+  const configSource = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "config.json")));
   if (configSource !== undefined) {
-    fs9.mkdirSync(input.configDir, { recursive: true });
-    fs9.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
+    fs10.mkdirSync(input.configDir, { recursive: true });
+    fs10.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
     const secrets = path10.join(configSource, "secrets.json");
-    if (fs9.existsSync(secrets)) {
-      fs9.copyFileSync(secrets, storePaths.secretsFile);
+    if (fs10.existsSync(secrets)) {
+      fs10.copyFileSync(secrets, storePaths.secretsFile);
       try {
-        fs9.chmodSync(storePaths.secretsFile, 384);
+        fs10.chmodSync(storePaths.secretsFile, 384);
       } catch {}
     }
-    fs9.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
+    fs10.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
   ${input.configDir}
 ` + `These files are no longer used. secrets.json still holds your bot token \u2014 delete this directory once you are satisfied.
 `);
     notes.push(`adopted configuration from ${configSource}`);
   }
-  const legacy = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "axterm.db")));
+  const legacy = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "axterm.db")));
   if (legacy !== undefined) {
     moveInto(legacy, input.stateDir, notes);
-    fs9.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
+    fs10.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
   ${input.stateDir}
 and configuration in:
   ${input.configDir}
@@ -4293,7 +4339,7 @@ and configuration in:
   if (configSource !== undefined)
     return { migrated: true, ...legacy ? { from: legacy } : {}, notes };
   const dbFile = path10.join(input.stateDir, "axterm.db");
-  if (!fs9.existsSync(dbFile))
+  if (!fs10.existsSync(dbFile))
     return { migrated: notes.length > 0, ...legacy ? { from: legacy } : {}, notes };
   const store = new Store(dbFile);
   const machine2 = store.getConfig("axterm_machine");
@@ -5131,13 +5177,13 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
 var init_axterm_agent_status = () => {};
 
 // packages/daemon/src/ext-install.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path11 from "path";
 function installExtensionAsset(targetDir) {
-  fs10.mkdirSync(targetDir, { recursive: true });
+  fs11.mkdirSync(targetDir, { recursive: true });
   const target = path11.join(targetDir, "axterm-agent-status.mjs");
   const js = new Bun.Transpiler({ loader: "ts" }).transformSync(extensionSource);
-  fs10.writeFileSync(target, MANAGED_HEADER + js);
+  fs11.writeFileSync(target, MANAGED_HEADER + js);
   return target;
 }
 var extensionSource, MANAGED_HEADER = `// @axterm-managed-omp-extension
@@ -5150,7 +5196,7 @@ var init_ext_install = __esm(() => {
 
 // packages/daemon/src/workspace-local.ts
 import { spawn as spawn2 } from "child_process";
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import path12 from "path";
 function isAbsent(error) {
   const code = error?.code;
@@ -5164,10 +5210,10 @@ class LocalWorkspace {
     this.stagingDir = stagingDir;
   }
   async list(dir) {
-    const dirents = await fs11.readdir(dir, { withFileTypes: true });
+    const dirents = await fs12.readdir(dir, { withFileTypes: true });
     const stats = await Promise.all(dirents.map(async (dirent) => {
       try {
-        return await fs11.lstat(path12.join(dir, dirent.name));
+        return await fs12.lstat(path12.join(dir, dirent.name));
       } catch (error) {
         if (isAbsent(error))
           return;
@@ -5191,7 +5237,7 @@ class LocalWorkspace {
   }
   async stat(target) {
     try {
-      const stat = await fs11.stat(target);
+      const stat = await fs12.stat(target);
       const kind = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
       return { kind, size: stat.size, mtimeMs: stat.mtimeMs };
     } catch (error) {
@@ -5202,8 +5248,8 @@ class LocalWorkspace {
   }
   async read(file, limit) {
     if (limit === undefined)
-      return await fs11.readFile(file);
-    const handle = await fs11.open(file, "r");
+      return await fs12.readFile(file);
+    const handle = await fs12.open(file, "r");
     try {
       const buffer = Buffer.allocUnsafe(Math.min(limit, (await handle.stat()).size));
       let filled = 0;
@@ -5222,10 +5268,10 @@ class LocalWorkspace {
     return Promise.resolve(file);
   }
   async mkdirp(dir, mode) {
-    await fs11.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
+    await fs12.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
   }
   async write(file, bytes, mode) {
-    await fs11.writeFile(file, bytes, mode === undefined ? undefined : { mode });
+    await fs12.writeFile(file, bytes, mode === undefined ? undefined : { mode });
   }
   exec(argv, cwd) {
     const [command, ...args] = argv;
@@ -5254,7 +5300,7 @@ var init_workspace_local = () => {};
 
 // packages/daemon/src/hook-host.ts
 import { randomBytes } from "crypto";
-import fs12 from "fs";
+import fs13 from "fs";
 import http from "http";
 import path13 from "path";
 function header(req, name) {
@@ -5270,6 +5316,7 @@ class HookHost {
   }
   sessions = new Map;
   pendingAsks = new Map;
+  refusedHooks = new Set;
   endpointFile;
   server;
   askOpenHandler;
@@ -5296,16 +5343,19 @@ class HookHost {
     return promise;
   }
   writeEndpointFile(port) {
-    fs12.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
+    fs13.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
     const tmp = `${this.endpointFile}.tmp`;
-    fs12.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
+    fs13.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
 AXTERM_HOOK_TOKEN=${this.token}
 `);
-    fs12.renameSync(tmp, this.endpointFile);
+    fs13.renameSync(tmp, this.endpointFile);
   }
   registerSession(sessionId, launchToken, onEvent) {
     this.sessions.set(sessionId, { launchToken, onEvent });
   }
+  launchMatches(session, presented) {
+    return session.launchToken === undefined || session.launchToken === presented;
+  }
   unregisterSession(sessionId) {
     this.sessions.delete(sessionId);
     for (const [askId, pending] of this.pendingAsks) {
@@ -5394,7 +5444,7 @@ AXTERM_HOOK_TOKEN=${this.token}
         res.writeHead(404).end();
         return;
       }
-      if (body.launchToken !== session.launchToken) {
+      if (!this.launchMatches(session, body.launchToken)) {
         res.writeHead(403).end();
         return;
       }
@@ -5429,7 +5479,9 @@ AXTERM_HOOK_TOKEN=${this.token}
       return;
     }
     res.writeHead(200).end();
-    this.dispatchHookPayloads(auth.session, map(input), agent);
+    const named = input;
+    const events = withConversationId(map(input), { sessionId: named.session_id, subagentId: named.agent_id });
+    this.dispatchHookPayloads(auth.session, events, agent);
   }
   handleCodex(req, raw, res) {
     const auth = this.agentHookSession(req);
@@ -5485,8 +5537,15 @@ AXTERM_HOOK_TOKEN=${this.token}
     const sessionId = header(req, "x-axterm-session");
     const launchToken = header(req, "x-axterm-launch");
     const session = sessionId === undefined ? undefined : this.sessions.get(sessionId);
-    if (sessionId === undefined || !session || session.launchToken !== launchToken)
+    if (sessionId === undefined || !session || !this.launchMatches(session, launchToken)) {
+      const why = sessionId === undefined ? "no session header" : !session ? "unknown session" : "launch token mismatch";
+      const key = `${req.url}\x00${sessionId ?? ""}\x00${why}`;
+      if (!this.refusedHooks.has(key)) {
+        this.refusedHooks.add(key);
+        log(`refused hook post to ${req.url}: ${why} (session ${sessionId ?? "-"}) \u2014 reported once per session`);
+      }
       return;
+    }
     return { sessionId, session };
   }
   dispatchHookPayloads(session, payloads, agent) {
@@ -5576,7 +5635,7 @@ var init_hook_host = __esm(() => {
 });
 
 // packages/daemon/src/rpc-server.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import net2 from "net";
 function writeFrame(socket, frame) {
   if (!socket.destroyed)
@@ -5686,6 +5745,8 @@ function startRpcServer(options) {
           session.write(Buffer.from(p["dataB64"], "base64").toString("utf8"));
           return {};
         }
+        case "session.choose":
+          return { answered: manager.answerScreenChoice(p["id"], p["index"]) };
         case "attach": {
           const session = manager.resolveLive(p["id"]);
           cleanup();
@@ -5812,7 +5873,7 @@ function startRpcServer(options) {
   });
   if (process.platform !== "win32") {
     try {
-      fs13.unlinkSync(pipePath);
+      fs14.unlinkSync(pipePath);
     } catch {}
   }
   server.listen(pipePath, () => {
@@ -5827,18 +5888,35 @@ var init_rpc_server = __esm(() => {
 });
 
 // packages/daemon/src/codex-home.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function codexTrustKeyPath(home) {
   const resolved = (() => {
     try {
-      return fs14.realpathSync.native(home);
+      return fs15.realpathSync.native(home);
     } catch {
       return path14.resolve(home);
     }
   })();
   return path14.join(resolved, "hooks.json");
 }
+function referenceCredential(source, target, ops) {
+  const symlink = ops?.symlink ?? ((s, t2) => fs15.symlinkSync(s, t2, "file"));
+  const link = ops?.link ?? fs15.linkSync;
+  try {
+    symlink(source, target);
+    return "symlink";
+  } catch {
+    try {
+      link(source, target);
+      return "hardlink";
+    } catch {
+      fs15.copyFileSync(source, target);
+      fs15.chmodSync(target, 384);
+      return "copy";
+    }
+  }
+}
 var init_codex_home = () => {};
 
 // packages/daemon/src/host-env.ts
@@ -5853,15 +5931,36 @@ function stripHostAttribution(env) {
 }
 var ATTRIBUTION_PREFIXES, ATTRIBUTION_KEEP;
 var init_host_env = __esm(() => {
-  ATTRIBUTION_PREFIXES = ["ORCA_"];
+  ATTRIBUTION_PREFIXES = ["ORCA_", "AXTERM_"];
   ATTRIBUTION_KEEP = new Set([
     "ORCA_CODEX_HOME",
     "ORCA_OPENCODE_CONFIG_DIR",
     "ORCA_USER_DATA_PATH",
-    "ORCA_APP_VERSION"
+    "ORCA_APP_VERSION",
+    "AXTERM_CONFIG_DIR",
+    "AXTERM_STATE_DIR",
+    "AXTERM_RUNTIME_DIR",
+    "AXTERM_LANG",
+    "AXTERM_PTY_HOST",
+    "AXTERM_PTY_HOST_MAIN"
   ]);
 });
 
+// packages/daemon/src/session-env.ts
+function sessionEnv(base, identity) {
+  return {
+    ...stripHostAttribution(base),
+    AXTERM_SESSION_ID: identity.sessionId,
+    AXTERM_LAUNCH_TOKEN: identity.launchToken,
+    AXTERM_HOOK_PORT: String(identity.hookPort),
+    AXTERM_HOOK_TOKEN: identity.hookToken,
+    AXTERM_HOOK_ENDPOINT: identity.endpointFile
+  };
+}
+var init_session_env = __esm(() => {
+  init_host_env();
+});
+
 // packages/daemon/src/git-porcelain.ts
 function parseWorktreeList(porcelain) {
   const entries = [];
@@ -5900,7 +5999,7 @@ function slugifyBranch(branch) {
 var MAX_SLUG_LENGTH = 60;
 
 // packages/daemon/src/git.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 async function git(ws, cwd, args) {
   const run = await ws.exec(["git", ...args], cwd);
@@ -5920,7 +6019,7 @@ async function gitOrThrow(ws, cwd, args) {
 function canonicalPath(target) {
   let resolved = path15.resolve(target);
   try {
-    resolved = fs15.realpathSync.native(resolved);
+    resolved = fs16.realpathSync.native(resolved);
   } catch {}
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -5944,7 +6043,7 @@ async function createWorktree(ws, options) {
   const existing = (await listWorktrees(ws, repoRoot)).find((w) => canonicalPath(w.path) === canonicalPath(target));
   if (existing)
     return { path: target, branch, createdBranch: false };
-  fs15.mkdirSync(path15.dirname(target), { recursive: true });
+  fs16.mkdirSync(path15.dirname(target), { recursive: true });
   const exists = (await git(ws, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).ok;
   const args = exists ? ["worktree", "add", target, branch] : ["worktree", "add", "-b", branch, target, ...base !== undefined ? [base] : []];
   await gitOrThrow(ws, repoRoot, args);
@@ -6035,7 +6134,7 @@ var init_git = __esm(() => {
 });
 
 // packages/daemon/src/claude-store.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import os4 from "os";
 import path16 from "path";
 function claudeConfigDir(env = process.env) {
@@ -6061,19 +6160,55 @@ function claudeConversationExists(configDir, conversationId) {
   const projects = path16.join(configDir, "projects");
   let entries;
   try {
-    entries = fs16.readdirSync(projects);
+    entries = fs17.readdirSync(projects);
   } catch {
     return;
   }
   const file = `${conversationId}.jsonl`;
   for (const entry of entries) {
     try {
-      if (fs16.existsSync(path16.join(projects, entry, file)))
+      if (fs17.existsSync(path16.join(projects, entry, file)))
         return true;
     } catch {}
   }
   return false;
 }
+function claudeConversationCwd(configDir, conversationId) {
+  const projects = path16.join(configDir, "projects");
+  let entries;
+  try {
+    entries = fs17.readdirSync(projects);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const file = path16.join(projects, entry, `${conversationId}.jsonl`);
+    let head;
+    try {
+      const handle = fs17.openSync(file, "r");
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        const read = fs17.readSync(handle, buffer, 0, buffer.byteLength, 0);
+        head = buffer.subarray(0, read).toString("utf8");
+      } finally {
+        fs17.closeSync(handle);
+      }
+    } catch {
+      continue;
+    }
+    for (const line of head.split(/\r?\n/)) {
+      if (line.length === 0)
+        continue;
+      try {
+        const record = JSON.parse(line);
+        const cwd = record.cwd;
+        if (typeof cwd === "string" && cwd.length > 0)
+          return cwd;
+      } catch {}
+    }
+  }
+  return;
+}
 var CONVERSATION_ID;
 var init_claude_store = __esm(() => {
   CONVERSATION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -6194,6 +6329,7 @@ function connectPtyHost(options) {
     const decoder = new FrameDecoder;
     const ptys = new Map;
     const pending = new Map;
+    const subscriptions = new Map;
     const dataListeners = [];
     const rawDecoders = new Map;
     let welcomed = false;
@@ -6207,6 +6343,9 @@ function connectPtyHost(options) {
       for (const waiter of pending.values())
         waiter.reject(error);
       pending.clear();
+      for (const waiter of subscriptions.values())
+        waiter.reject(error);
+      subscriptions.clear();
       socket.destroy();
     };
     const timer = setTimeout(() => fail(new Error(`pty host did not greet within ${options.timeoutMs ?? 5000}ms`)), options.timeoutMs ?? 5000);
@@ -6273,6 +6412,15 @@ function connectPtyHost(options) {
                 term: spawnOptions.term
               }));
             }),
+            adopt: (session) => new Promise((done, failed) => {
+              const pty = ptys.get(session.id) ?? new RemotePty(session.id, session.pid, send);
+              ptys.set(session.id, pty);
+              subscriptions.set(session.id, {
+                resolve: () => done(pty),
+                reject: failed
+              });
+              send(controlFrame({ t: "subscribe", id: session.id, replay: true }));
+            }),
             onData: (listener) => dataListeners.push(listener),
             close: () => socket.destroy()
           });
@@ -6288,10 +6436,17 @@ function connectPtyHost(options) {
           pending.delete(message.id);
           continue;
         }
+        if (message.t === "subscribed") {
+          subscriptions.get(message.id)?.resolve();
+          subscriptions.delete(message.id);
+          continue;
+        }
         if (message.t === "exit") {
           const pty = ptys.get(message.id);
           ptys.delete(message.id);
           rawDecoders.delete(message.id);
+          subscriptions.get(message.id)?.reject(new Error(`session ${message.id} exited`));
+          subscriptions.delete(message.id);
           pty?.finish(message.code);
         }
       }
@@ -6304,15 +6459,18 @@ var init_pty_host_client = __esm(() => {
 
 // packages/daemon/src/pty-host-launch.ts
 import { spawn as spawn3 } from "child_process";
-import fs17 from "fs";
+import fs18 from "fs";
 import os5 from "os";
 import path17 from "path";
 function hostFile(runtimeDir) {
   return path17.join(runtimeDir, "pty-host.json");
 }
+function readPtyHostIn(runtimeDir) {
+  return readPtyHostFile(hostFile(runtimeDir));
+}
 function readPtyHostFile(file) {
   try {
-    const parsed = JSON.parse(fs17.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return;
     const { pid, endpoint, token, version: version2 } = parsed;
@@ -6344,7 +6502,7 @@ async function ensurePtyHost(location) {
     log(`pty host: handoff file names a dead pid ${existing.pid}, starting a new host`);
   const endpoint = hostEndpoint(location.runtimeDir);
   if (process.platform !== "win32")
-    fs17.rmSync(endpoint, { force: true });
+    fs18.rmSync(endpoint, { force: true });
   const token = shortHash(`${location.runtimeDir}:${Date.now()}:${Math.random()}`) + shortHash(String(process.pid));
   const launch = ptyHostLaunch({ execPath: process.execPath, mainScript: location.mainScript ?? Bun.main });
   const child = spawn3(launch.command, launch.args, {
@@ -6373,8 +6531,8 @@ async function ensurePtyHost(location) {
   }
 }
 function writePtyHostFile(file, info) {
-  fs17.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
-  fs17.writeFileSync(file, `${JSON.stringify(info, null, 2)}
+  fs18.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
+  fs18.writeFileSync(file, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
   restrictFile(file);
 }
@@ -6494,7 +6652,7 @@ var init_pty = () => {};
 
 // packages/daemon/src/occupancy.ts
 import { spawn as spawn4 } from "child_process";
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 function shellOccupied(shellPid) {
   return process.platform === "win32" ? occupiedFromSnapshot(shellPid) : occupiedFromPidProbe(shellPid);
 }
@@ -6539,11 +6697,11 @@ async function occupiedFromSnapshot(shellPid) {
 }
 async function childrenViaProc(pid) {
   try {
-    const children = await fs18.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    const children = await fs19.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
     return children.trim().length > 0;
   } catch {
     try {
-      await fs18.access(`/proc/${pid}`);
+      await fs19.access(`/proc/${pid}`);
       return;
     } catch {
       return false;
@@ -6607,20 +6765,20 @@ var init_occupancy = __esm(() => {
 });
 
 // packages/daemon/src/agent-store.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import os6 from "os";
 import path19 from "path";
 import { Database as Database3 } from "bun:sqlite";
 function readTailLines(file, maxBytes) {
   let fd;
   try {
-    fd = fs19.openSync(file, "r");
-    const size = fs19.fstatSync(fd).size;
+    fd = fs20.openSync(file, "r");
+    const size = fs20.fstatSync(fd).size;
     if (size === 0)
       return [];
     const length = Math.min(size, maxBytes);
     const buffer = Buffer.allocUnsafe(length);
-    fs19.readSync(fd, buffer, 0, length, size - length);
+    fs20.readSync(fd, buffer, 0, length, size - length);
     const text = buffer.toString("utf8");
     const lines = text.split(`
 `);
@@ -6633,7 +6791,7 @@ function readTailLines(file, maxBytes) {
     return [];
   } finally {
     if (fd !== undefined)
-      fs19.closeSync(fd);
+      fs20.closeSync(fd);
   }
 }
 function claudeConfigDir2() {
@@ -6651,7 +6809,7 @@ function findCodexRollout(sessionId) {
     const dir = path19.join(root, ...shard2.split("/"));
     let entries;
     try {
-      entries = fs19.readdirSync(dir);
+      entries = fs20.readdirSync(dir);
     } catch {
       continue;
     }
@@ -6667,7 +6825,7 @@ function newestCodexRollout() {
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs19.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -6681,7 +6839,7 @@ function newestCodexRollout() {
       if (!entry.name.endsWith(".jsonl"))
         continue;
       try {
-        const { mtimeMs } = fs19.statSync(full);
+        const { mtimeMs } = fs20.statSync(full);
         if (!best || mtimeMs > best.mtimeMs)
           best = { file: full, mtimeMs };
       } catch {}
@@ -6692,7 +6850,7 @@ function newestCodexRollout() {
 }
 function ompQuotaFacts() {
   const file = ompAgentDb();
-  if (!fs19.existsSync(file))
+  if (!fs20.existsSync(file))
     return { agent: "omp", kind: "gauge" };
   let db;
   try {
@@ -6760,7 +6918,7 @@ function storeQuietForMs(agent, cwd, agentSessionId, nowMs) {
   if (file === undefined)
     return;
   try {
-    return Math.max(0, nowMs - fs19.statSync(file).mtimeMs);
+    return Math.max(0, nowMs - fs20.statSync(file).mtimeMs);
   } catch {
     return;
   }
@@ -6770,15 +6928,15 @@ function readFileRange(file, from, to) {
     return "";
   let fd;
   try {
-    fd = fs19.openSync(file, "r");
+    fd = fs20.openSync(file, "r");
     const buffer = Buffer.allocUnsafe(to - from);
-    const read = fs19.readSync(fd, buffer, 0, to - from, from);
+    const read = fs20.readSync(fd, buffer, 0, to - from, from);
     return buffer.subarray(0, read).toString("utf8");
   } catch {
     return "";
   } finally {
     if (fd !== undefined)
-      fs19.closeSync(fd);
+      fs20.closeSync(fd);
   }
 }
 var QUOTA_TAIL_BYTES;
@@ -11229,15 +11387,55 @@ var require_addon_serialize = __commonJS((exports, module) => {
   })());
 });
 
+// packages/daemon/src/terminal-mirror.ts
+class TerminalMirror {
+  scrollbackLines;
+  term;
+  serializeAddon;
+  constructor(cols, rows, scrollbackLines) {
+    this.scrollbackLines = scrollbackLines;
+    this.term = new import_headless.Terminal({ cols, rows, scrollback: scrollbackLines, allowProposedApi: true });
+    this.serializeAddon = new import_addon_serialize.SerializeAddon;
+    this.term.loadAddon(this.serializeAddon);
+  }
+  write(data) {
+    this.term.write(data);
+  }
+  resize(cols, rows) {
+    this.term.resize(cols, rows);
+  }
+  serialize(maxChars = Number.POSITIVE_INFINITY) {
+    const ansi = this.serializeAddon.serialize({ scrollback: this.scrollbackLines });
+    return ansi.length > maxChars ? ansi.slice(-maxChars) : ansi;
+  }
+  text(maxLines) {
+    const buffer = this.term.buffer.active;
+    let last = buffer.length - 1;
+    while (last >= 0 && (buffer.getLine(last)?.translateToString(true).trim() ?? "") === "")
+      last--;
+    const start = Math.max(0, last - maxLines + 1);
+    const lines = [];
+    for (let y = start;y <= last; y++) {
+      lines.push(buffer.getLine(y)?.translateToString(true).trimEnd() ?? "");
+    }
+    return lines.join(`
+`);
+  }
+}
+var import_headless, import_addon_serialize;
+var init_terminal_mirror = __esm(() => {
+  import_headless = __toESM(require_xterm_headless(), 1);
+  import_addon_serialize = __toESM(require_addon_serialize(), 1);
+});
+
 // packages/daemon/src/pty-session.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import path20 from "path";
 
 class PtySession {
   info;
   pty;
-  term;
-  serializeAddon;
+  mirror;
   dataListeners = new Set;
   exitListeners = new Set;
   saveTimer;
@@ -11254,26 +11452,23 @@ class PtySession {
       cols: spawn5.cols,
       rows: spawn5.rows,
       env: spawn5.env,
-      term: "xterm-256color"
+      term: "xterm-256color",
+      id: info.id
     });
     return new PtySession(info, spawn5, pty);
   }
+  static adopt(info, pty, cols, rows) {
+    return new PtySession(info, { exe: "", argv: [], cwd: info.cwd, cols, rows, env: {} }, pty);
+  }
   constructor(info, spawn5, pty) {
     this.info = info;
-    this.term = new import_headless.Terminal({
-      cols: spawn5.cols,
-      rows: spawn5.rows,
-      scrollback: SCROLLBACK_LINES,
-      allowProposedApi: true
-    });
-    this.serializeAddon = new import_addon_serialize.SerializeAddon;
-    this.term.loadAddon(this.serializeAddon);
+    this.mirror = new TerminalMirror(spawn5.cols, spawn5.rows, SCROLLBACK_LINES);
     this.pty = pty;
     info.ptyPid = this.pty.pid;
     this.pty.onData((data) => {
       this.seq += 1;
       this.lastOutputAt = Date.now();
-      this.term.write(data);
+      this.mirror.write(data);
       if (!this.pasteReady) {
         const window2 = this.readyScanTail + data;
         if (window2.includes("\x1B[?2004h"))
@@ -11318,27 +11513,16 @@ class PtySession {
     this.info.rows = rows;
     try {
       this.pty.resize(cols, rows);
-      this.term.resize(cols, rows);
+      this.mirror.resize(cols, rows);
     } catch (err) {
       log(`resize failed for ${this.info.shortId}: ${String(err)}`);
     }
   }
   screenText(maxLines = 60) {
-    const buffer = this.term.buffer.active;
-    let last = buffer.length - 1;
-    while (last >= 0 && (buffer.getLine(last)?.translateToString(true).trim() ?? "") === "")
-      last--;
-    const start = Math.max(0, last - maxLines + 1);
-    const lines = [];
-    for (let y = start;y <= last; y++) {
-      lines.push(buffer.getLine(y)?.translateToString(true).trimEnd() ?? "");
-    }
-    return lines.join(`
-`);
+    return this.mirror.text(maxLines);
   }
   serializeBuffer() {
-    const ansi = this.serializeAddon.serialize({ scrollback: SCROLLBACK_LINES });
-    return ansi.length > SCROLLBACK_MAX_CHARS ? ansi.slice(-SCROLLBACK_MAX_CHARS) : ansi;
+    return this.mirror.serialize(SCROLLBACK_MAX_CHARS);
   }
   scheduleSave() {
     if (this.exited || this.saveTimer)
@@ -11353,8 +11537,8 @@ class PtySession {
     try {
       const file = path20.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
       const tmp = `${file}.tmp`;
-      fs20.writeFileSync(tmp, this.serializeBuffer(), "utf8");
-      fs20.renameSync(tmp, file);
+      fs21.writeFileSync(tmp, this.serializeBuffer(), "utf8");
+      fs21.renameSync(tmp, file);
     } catch (err) {
       log(`scrollback save failed for ${this.info.shortId}: ${String(err)}`);
     }
@@ -11365,18 +11549,18 @@ class PtySession {
     this.pty.kill();
   }
 }
-var import_headless, import_addon_serialize, SCROLLBACK_LINES = 5000, SAVE_DEBOUNCE_MS = 5000, SCROLLBACK_MAX_CHARS;
+var SCROLLBACK_LINES = 5000, SAVE_DEBOUNCE_MS = 5000, SCROLLBACK_MAX_CHARS;
 var init_pty_session = __esm(() => {
   init_paths();
   init_pty();
-  import_headless = __toESM(require_xterm_headless(), 1);
-  import_addon_serialize = __toESM(require_addon_serialize(), 1);
+  init_terminal_mirror();
   SCROLLBACK_MAX_CHARS = 2 * 1024 * 1024;
 });
 
 // packages/daemon/src/session-manager.ts
 import { randomBytes as randomBytes2, randomUUID } from "crypto";
-import fs21 from "fs";
+import { spawn as spawn5 } from "child_process";
+import fs22 from "fs";
 import os7 from "os";
 import path21 from "path";
 function sessionScratchRoot(info) {
@@ -11420,6 +11604,14 @@ async function sendableNow(runtime, info, probe, now) {
     occupied
   }, now);
 }
+function pidIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 
 class SessionManager {
   store;
@@ -11436,14 +11628,58 @@ class SessionManager {
     this.store = store;
     this.hooks = hooks;
     this.configuredDefaults = configuredDefaults;
-    const stale = store.markStaleRunningAsExited();
-    if (stale > 0)
-      log(`boot: marked ${stale} stale session(s) as exited`);
     this.sessionWatch = setInterval(() => this.tickSessions(), SESSION_TICK_MS);
     this.sessionWatch.unref();
   }
+  async recover() {
+    const running = this.store.listSessions().filter((info) => info.state !== "exited");
+    const held = await this.hostSessions();
+    const adoptedIds = [];
+    for (const info of running) {
+      const description = held.get(info.id);
+      if (description === undefined)
+        continue;
+      try {
+        const handle = await this.ptyHost.adopt(description);
+        info.state = "running";
+        delete info.exitCode;
+        delete info.exitedAt;
+        const session = PtySession.adopt(info, handle, description.cols, description.rows);
+        this.wire(session, undefined);
+        this.hostOwned.add(info.id);
+        this.store.markResumed(info.id, info.agentCommand, info.ptyPid);
+        if (agentIdFromCommand(info.agentCommand) === "codex")
+          this.adoptCodexAppServer(info.id);
+        if (agentIdFromCommand(info.agentCommand) === "gemini")
+          this.skipGeminiTelemetryHistory(info.id);
+        adoptedIds.push(info.id);
+        log(`boot: adopted session ${info.shortId} (pty ${description.pid}) from the terminal host`);
+      } catch (err) {
+        log(`boot: could not adopt ${info.shortId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const sweptExited = this.store.markStaleRunningAsExited(adoptedIds);
+    if (sweptExited > 0)
+      log(`boot: marked ${sweptExited} stale session(s) as exited`);
+    return { adopted: adoptedIds.length, sweptExited };
+  }
+  async hostSessions() {
+    if (process.env["AXTERM_PTY_HOST"] !== "1")
+      return new Map;
+    const existing = readPtyHostIn(RUNTIME_DIR);
+    if (existing === undefined)
+      return new Map;
+    try {
+      this.ptyHost ??= await connectPtyHost({ endpoint: existing.endpoint, token: existing.token });
+      return new Map(this.ptyHost.sessions.map((s) => [s.id, s]));
+    } catch (err) {
+      log(`boot: the terminal host named in pty-host.json did not answer: ${err instanceof Error ? err.message : String(err)}`);
+      return new Map;
+    }
+  }
   sessionWatch;
   ptyHost;
+  hostOwned = new Set;
   ptyHostUnavailable = false;
   codexServers = new Map;
   workspaceFor(_sessionId) {
@@ -11523,7 +11759,7 @@ class SessionManager {
   }
   async create(params) {
     const requestedCwd = params.cwd ? path21.resolve(params.cwd) : os7.homedir();
-    if (!fs21.existsSync(requestedCwd)) {
+    if (!fs22.existsSync(requestedCwd)) {
       throw new AxtermError("err.cwd.missing", { cwd: requestedCwd });
     }
     let worktree;
@@ -11567,11 +11803,27 @@ class SessionManager {
     const missing = unresolvableAgent(params.commandOverride, agentCommand, lookupOnPath);
     if (missing !== undefined)
       throw new AxtermError("err.agent.notInstalled", { command: missing });
+    const adopted = agent === "claude" ? resumedConversationId(agentCommand) : undefined;
+    let sessionCwd = cwd;
+    if (adopted !== undefined) {
+      const holder = conversationHeldBy(this.allSessions(), adopted);
+      if (holder !== undefined) {
+        throw new AxtermError("err.claude.conversationBusy", { id: adopted, session: holder.shortId });
+      }
+      if (worktree === undefined) {
+        const recorded = claudeConversationCwd(claudeConfigDir(), adopted);
+        sessionCwd = resolveSessionCwd({
+          requested: cwd,
+          preferConversation: params.preferConversationCwd === true,
+          ...recorded !== undefined && fs22.existsSync(recorded) ? { conversationCwd: recorded } : {}
+        });
+      }
+    }
     const info = {
       id,
       shortId: id.slice(0, 6),
-      name: params.name ?? worktree?.branch ?? path21.basename(cwd),
-      cwd,
+      name: params.name ?? worktree?.branch ?? path21.basename(sessionCwd),
+      cwd: sessionCwd,
       shell: shell.kind,
       agentCommand,
       state: "running",
@@ -11580,8 +11832,7 @@ class SessionManager {
       createdAt: Date.now(),
       ...worktree !== undefined ? { worktreePath: worktree.path, branch: worktree.branch, repoRoot: worktree.repoRoot } : {}
     };
-    const appServerUrl = agent === "codex" ? await this.startCodexAppServer(id, this.ensureCodexHome(), cwd) : undefined;
-    await this.launch(info, shell, agentCommand, appServerUrl);
+    await this.launch(info, shell, agentCommand);
     this.store.insertSession(info);
     log(`session ${info.shortId} created shell=${shell.kind} cmd=${agentCommand.join(" ") || "(shell only)"}`);
     this.emit({ t: "session.created", info });
@@ -11595,7 +11846,7 @@ class SessionManager {
       launchToken
     });
     const file = this.claudeSettingsPath(id);
-    fs21.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
+    fs22.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
   }
   writeGeminiSettings(sessionId) {
     try {
@@ -11608,69 +11859,104 @@ class SessionManager {
       });
       const file = this.geminiSettingsPath();
       const tmp = `${file}.tmp`;
-      fs21.writeFileSync(tmp, JSON.stringify(settings, null, 2));
-      fs21.renameSync(tmp, file);
+      fs22.writeFileSync(tmp, JSON.stringify(settings, null, 2));
+      fs22.renameSync(tmp, file);
     } catch (err) {
       log(`gemini settings write failed; session starts without hooks: ${String(err)}`);
     }
   }
-  async startCodexAppServer(id, codexHome2, cwd) {
+  async startCodexAppServer(id, codexHome2, cwd, identity) {
     try {
+      const inherited = this.adoptCodexAppServer(id);
+      if (inherited !== undefined)
+        return inherited;
       const port = await freeLoopbackPort();
       const url = `ws://127.0.0.1:${port}`;
-      const proc = Bun.spawn(["codex", "app-server", "--listen", url], {
+      const child = spawn5("codex", ["app-server", "--listen", url], {
         cwd,
-        env: { ...stripHostAttribution(process.env), CODEX_HOME: codexHome2 },
-        stdout: "ignore",
-        stderr: "ignore",
-        stdin: "ignore"
+        detached: true,
+        windowsHide: true,
+        stdio: "ignore",
+        env: { ...sessionEnv(process.env, identity), CODEX_HOME: codexHome2 }
       });
+      child.unref();
+      const pid = child.pid;
+      if (pid === undefined)
+        throw new Error("the app-server was not given a pid");
       if (!await waitForPort(port)) {
-        proc.kill();
+        this.killCodexAppServer(pid);
         log(`codex app-server did not open ${port}; session ${id.slice(0, 6)} keeps its hooks`);
         return;
       }
-      const client = new CodexAppServerClient(url, (payload) => this.ingestHookEvent(id, payload));
-      client.connect();
-      this.codexServers.set(id, {
-        stop: () => {
-          client.close();
-          try {
-            killTree(proc.pid, "codex.exe");
-          } catch {}
-          try {
-            proc.kill();
-          } catch {}
-        }
-      });
-      log(`codex app-server on ${url} for session ${id.slice(0, 6)} in ${cwd}`);
+      this.watchCodexAppServer(id, url, pid);
+      fs22.writeFileSync(this.codexAppServerFile(id), JSON.stringify({ pid, url }), { mode: 384 });
+      log(`codex app-server on ${url} (pid ${pid}) for session ${id.slice(0, 6)} in ${cwd}`);
       return url;
     } catch (err) {
       log(`codex app-server unavailable (${String(err)}); session ${id.slice(0, 6)} keeps its hooks`);
       return;
     }
   }
+  codexAppServerFile(id) {
+    return path21.join(RUNTIME_DIR, `codex-app-${id}.json`);
+  }
+  adoptCodexAppServer(id) {
+    const file = this.codexAppServerFile(id);
+    let record;
+    try {
+      record = JSON.parse(fs22.readFileSync(file, "utf8"));
+    } catch {
+      return;
+    }
+    const pid = record.pid;
+    const url = record.url;
+    if (typeof pid !== "number" || typeof url !== "string")
+      return;
+    if (!pidIsRunning(pid)) {
+      fs22.rmSync(file, { force: true });
+      return;
+    }
+    this.watchCodexAppServer(id, url, pid);
+    log(`codex app-server: reconnected to ${url} (pid ${pid}) for session ${id.slice(0, 6)}`);
+    return url;
+  }
+  watchCodexAppServer(id, url, pid) {
+    const client = new CodexAppServerClient(url, (payload) => this.ingestHookEvent(id, payload));
+    client.connect();
+    this.codexServers.set(id, {
+      stop: () => {
+        client.close();
+        this.killCodexAppServer(pid);
+        fs22.rmSync(this.codexAppServerFile(id), { force: true });
+      }
+    });
+  }
+  killCodexAppServer(pid) {
+    try {
+      killTree(pid, "codex.exe");
+    } catch {}
+  }
   stopCodexAppServer(id) {
     this.codexServers.get(id)?.stop();
     this.codexServers.delete(id);
   }
   ensureCodexHome() {
     const home = path21.join(STATE_DIR, "codex-home");
-    fs21.mkdirSync(home, { recursive: true, mode: 448 });
+    fs22.mkdirSync(home, { recursive: true, mode: 448 });
     this.linkCodexAuth(home);
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
     const hooksFile = buildCodexHooks({ command: bridge.command, args: bridge.args });
     const hooksPath = codexTrustKeyPath(home);
     const tmp = `${hooksPath}.tmp`;
-    fs21.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
-    fs21.renameSync(tmp, hooksPath);
+    fs22.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
+    fs22.renameSync(tmp, hooksPath);
     const entries = codexHookTrust(hooksPath, hooksFile);
     const configPath = path21.join(home, "config.toml");
-    const existing = fs21.existsSync(configPath) ? fs21.readFileSync(configPath, "utf8") : "";
+    const existing = fs22.existsSync(configPath) ? fs22.readFileSync(configPath, "utf8") : "";
     const missing = entries.filter((e) => !existing.includes(`"${e.key.replaceAll("\\", "\\\\")}"`));
     if (missing.length > 0) {
       const block = codexTrustStateToml(missing);
-      fs21.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
+      fs22.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
 `) ? `
 ${block}` : block);
     }
@@ -11684,20 +11970,20 @@ ${block}` : block);
   }
   linkCodexAuth(home) {
     const target = path21.join(home, "auth.json");
-    if (fs21.existsSync(target))
+    if (fs22.existsSync(target))
       return;
     const operatorHome = process.env["CODEX_HOME"] ?? path21.join(os7.homedir(), ".codex");
     const source = path21.join(operatorHome, "auth.json");
-    if (!fs21.existsSync(source))
+    if (!fs22.existsSync(source))
       throw new AxtermError("err.codex.noAuth", { authFile: source });
+    let how;
     try {
-      fs21.symlinkSync(source, target, "file");
-    } catch {
-      try {
-        fs21.linkSync(source, target);
-      } catch (err) {
-        throw new AxtermError("err.codex.authLink", { reason: err instanceof Error ? err.message : String(err) });
-      }
+      how = referenceCredential(source, target);
+    } catch (err) {
+      throw new AxtermError("err.codex.authLink", { reason: err instanceof Error ? err.message : String(err) });
+    }
+    if (how === "copy") {
+      log(`codex auth: neither a symlink nor a hard link to ${source} was possible (state dir on another volume?) \u2014 ` + `copied instead, so a token refresh will not follow; delete ${target} to re-reference it`);
     }
   }
   doctorReport() {
@@ -11709,24 +11995,24 @@ ${block}` : block);
     const configPath = path21.join(home, "config.toml");
     const read = (file) => {
       try {
-        return fs21.existsSync(file) ? fs21.readFileSync(file, "utf8") : undefined;
+        return fs22.existsSync(file) ? fs22.readFileSync(file, "utf8") : undefined;
       } catch {
         return;
       }
     };
     return [
-      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs21.existsSync(bridge.command) }),
+      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs22.existsSync(bridge.command) }),
       ...evaluateOmpDoctor({
         binary: lookupOnPath("omp"),
         extensionPath: this.hooks.extensionPath,
-        extensionExists: fs21.existsSync(this.hooks.extensionPath)
+        extensionExists: fs22.existsSync(this.hooks.extensionPath)
       }),
       ...evaluateClaudeDoctor({ binary: lookupOnPath("claude") }),
       ...evaluateCodexDoctor({
         binary: lookupOnPath("codex"),
         authSourcePath: authSource,
-        authSourceExists: fs21.existsSync(authSource),
-        homeExists: fs21.existsSync(home),
+        authSourceExists: fs22.existsSync(authSource),
+        homeExists: fs22.existsSync(home),
         expected: codexHookTrust(codexTrustKeyPath(home), buildCodexHooks({ command: bridge.command, args: bridge.args })),
         configToml: read(configPath)
       }),
@@ -11825,6 +12111,18 @@ ${block}` : block);
     session.write(digit);
     return true;
   }
+  answerScreenChoice(idOrPrefix, optionIndex) {
+    const session = this.resolveLive(idOrPrefix);
+    const dialog = detectOnboarding(agentIdFromCommand(session.info.agentCommand), session.screenText(30));
+    const digit = dialog?.options[optionIndex]?.digit;
+    if (digit === undefined) {
+      session.write(buildMenuSelectKeys(optionIndex));
+      return "menu";
+    }
+    this.pendingPrompt.delete(session.info.id);
+    session.write(digit);
+    return "onboarding";
+  }
   sinceLastCapture(id) {
     const at = this.lastCaptureAt.get(id);
     return at === undefined ? undefined : Date.now() - at;
@@ -11852,12 +12150,12 @@ ${block}` : block);
   writeScreenFile(idOrPrefix, lines) {
     const session = this.resolveLive(idOrPrefix);
     const file = path21.join(path21.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
-    fs21.writeFileSync(file, session.screenText(lines), { mode: 384 });
+    fs22.writeFileSync(file, session.screenText(lines), { mode: 384 });
     return file;
   }
   removeScreenFile(id) {
     try {
-      fs21.rmSync(path21.join(path21.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
+      fs22.rmSync(path21.join(path21.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
     } catch {}
   }
   async stageInboundFile(idOrPrefix, suggestedName, bytes) {
@@ -11877,8 +12175,8 @@ ${block}` : block);
   }
   async stageInRuntimeDir(info, suggestedName, bytes) {
     const file = path21.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
-    await fs21.promises.mkdir(path21.dirname(file), { recursive: true, mode: 448 });
-    await fs21.promises.writeFile(file, bytes, { mode: 384 });
+    await fs22.promises.mkdir(path21.dirname(file), { recursive: true, mode: 448 });
+    await fs22.promises.writeFile(file, bytes, { mode: 384 });
     log(`session ${info.shortId} staged ${path21.basename(file)} (${bytes.byteLength} bytes, runtime dir)`);
     return file;
   }
@@ -11903,24 +12201,24 @@ ${block}` : block);
   }
   removeStagedFiles(id, info) {
     try {
-      fs21.rmSync(path21.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+      fs22.rmSync(path21.join(MATERIALISED_DIR, id), { recursive: true, force: true });
     } catch {}
     if (info === undefined)
       return;
     const scratch = path21.resolve(scratchDir(sessionScratchRoot(info)));
     try {
-      fs21.rmSync(path21.resolve(inboundStagingDir(sessionScratchRoot(info)), id), { recursive: true, force: true });
-      fs21.rmdirSync(path21.join(scratch, "inbound"));
-      fs21.rmSync(path21.join(scratch, SCRATCH_IGNORE_NAME), { force: true });
-      fs21.rmdirSync(scratch);
+      fs22.rmSync(path21.resolve(inboundStagingDir(sessionScratchRoot(info)), id), { recursive: true, force: true });
+      fs22.rmdirSync(path21.join(scratch, "inbound"));
+      fs22.rmSync(path21.join(scratch, SCRATCH_IGNORE_NAME), { force: true });
+      fs22.rmdirSync(scratch);
     } catch {}
   }
   removeClaudeSettings(id) {
     try {
-      fs21.rmSync(this.claudeSettingsPath(id), { force: true });
-      fs21.rmSync(this.mcpConfigPath(id), { force: true });
-      fs21.rmSync(this.mcpContextPath(id), { force: true });
-      fs21.rmSync(this.geminiTelemetryPath(id), { force: true });
+      fs22.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs22.rmSync(this.mcpConfigPath(id), { force: true });
+      fs22.rmSync(this.mcpContextPath(id), { force: true });
+      fs22.rmSync(this.geminiTelemetryPath(id), { force: true });
       this.stopCodexAppServer(id);
     } catch {}
   }
@@ -11936,7 +12234,7 @@ ${block}` : block);
   writeMcpContext(id, launchToken) {
     const file = this.mcpContextPath(id);
     try {
-      fs21.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
+      fs22.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp context write failed; session starts without axterm's tools: ${String(err)}`);
@@ -11949,7 +12247,7 @@ ${block}` : block);
   writeMcpConfig(id, contextPath) {
     const file = this.mcpConfigPath(id);
     try {
-      fs21.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
+      fs22.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp config write failed; session starts without axterm's tools: ${String(err)}`);
@@ -11964,7 +12262,7 @@ ${block}` : block);
   }
   async ptySpawner() {
     if (process.env["AXTERM_PTY_HOST"] !== "1" || this.ptyHostUnavailable)
-      return spawnPty;
+      return { spawn: spawnPty, hostOwned: false };
     try {
       if (this.ptyHost === undefined) {
         const override = process.env["AXTERM_PTY_HOST_MAIN"];
@@ -11973,11 +12271,11 @@ ${block}` : block);
         log(`pty host: connected (pid ${info.pid})`);
       }
       const host = this.ptyHost;
-      return (options) => host.spawn(options);
+      return { spawn: (options) => host.spawn(options), hostOwned: true };
     } catch (err) {
       this.ptyHostUnavailable = true;
       log(`pty host unavailable, owning ptys in this process: ${err instanceof Error ? err.message : String(err)}`);
-      return spawnPty;
+      return { spawn: spawnPty, hostOwned: false };
     }
   }
   requireClaudeConversation(agentCommand) {
@@ -11988,7 +12286,7 @@ ${block}` : block);
       throw new AxtermError("err.claude.noConversation", { id: conversation });
     }
   }
-  async launch(info, shell, agentCommand, appServerUrl) {
+  async launch(info, shell, agentCommand) {
     const id = info.id;
     const launchToken = randomBytes2(16).toString("hex");
     const agentId = agentIdFromCommand(info.agentCommand);
@@ -11996,11 +12294,22 @@ ${block}` : block);
       this.writeClaudeSettings(id, launchToken);
     if (agentId !== "omp")
       this.writeMcpContext(id, launchToken);
+    if (agentId === "claude")
+      this.writeMcpConfig(id, this.mcpContextPath(id));
     if (agentId === "gemini")
       this.writeGeminiSettings(id);
     const codexHome2 = agentId === "codex" ? this.ensureCodexHome() : undefined;
     if (agentId === "claude")
       this.requireClaudeConversation(agentCommand);
+    const identity = {
+      sessionId: id,
+      launchToken,
+      hookPort: this.hooks.port,
+      hookToken: this.hooks.host.token,
+      endpointFile: this.hooks.endpointFile
+    };
+    const appServerUrl = codexHome2 === undefined ? undefined : await this.startCodexAppServer(id, codexHome2, info.cwd, identity);
+    const spawner = await this.ptySpawner();
     const session = await PtySession.open(info, {
       exe: shell.exe,
       argv: buildShellArgv(shell, withAppServer(agentCommand, appServerUrl)),
@@ -12008,12 +12317,7 @@ ${block}` : block);
       cols: info.cols,
       rows: info.rows,
       env: {
-        ...stripHostAttribution(process.env),
-        AXTERM_SESSION_ID: id,
-        AXTERM_LAUNCH_TOKEN: launchToken,
-        AXTERM_HOOK_PORT: String(this.hooks.port),
-        AXTERM_HOOK_TOKEN: this.hooks.host.token,
-        AXTERM_HOOK_ENDPOINT: this.hooks.endpointFile,
+        ...sessionEnv(process.env, identity),
         ...agentId === "gemini" ? {
           GEMINI_CLI_SYSTEM_DEFAULTS_PATH: this.geminiSettingsPath(),
           GEMINI_TELEMETRY_ENABLED: "true",
@@ -12024,7 +12328,15 @@ ${block}` : block);
         } : {},
         ...codexHome2 !== undefined ? { CODEX_HOME: codexHome2 } : {}
       }
-    }, await this.ptySpawner());
+    }, spawner.spawn);
+    if (spawner.hostOwned)
+      this.hostOwned.add(id);
+    this.wire(session, launchToken);
+    return session;
+  }
+  wire(session, launchToken) {
+    const id = session.info.id;
+    const info = session.info;
     this.agentRuntime.set(id, { agentExited: false, choiceSeq: 0, dialogOpen: false });
     this.hooks.host.registerSession(id, launchToken, (payload) => this.ingestHookEvent(id, payload));
     session.onData(() => {
@@ -12051,11 +12363,11 @@ ${block}` : block);
       this.pendingPrompt.delete(id);
       this.live.delete(id);
       this.agentRuntime.delete(id);
+      this.hostOwned.delete(id);
       log(`session ${info.shortId} exited code=${code}`);
       this.emit({ t: "session.exit", sessionId: id, code });
     });
     this.live.set(id, session);
-    return session;
   }
   emitActivity(id, payload) {
     const dropped = payload.dropped;
@@ -12226,38 +12538,14 @@ ${block}` : block);
   allSessions() {
     return sessionsByRecency([...this.live.values()].map((s) => s.info), this.store.listSessions());
   }
-  async resumeNamed(stored, agent) {
-    const mcpConfigPath = agent === "claude" ? this.writeMcpConfig(stored.id, this.mcpContextPath(stored.id)) : undefined;
-    const agentCommand = buildAgentResumeCommand({
-      agent,
-      sessionId: stored.id,
-      extensionPath: this.hooks.extensionPath,
-      claudeSettingsPath: this.claudeSettingsPath(stored.id),
-      ...mcpConfigPath === undefined ? {} : { mcpConfigPath },
-      storedArgv: stored.agentCommand
-    });
-    const info = { ...stored, agentCommand, state: "running" };
-    delete info.exitCode;
-    delete info.exitedAt;
-    delete info.agentState;
-    delete info.agentStateSource;
-    await this.launch(info, resolveShell(info.shell), agentCommand);
-    this.store.markResumed(info.id, agentCommand, info.ptyPid);
-    log(`session ${info.shortId} resumed cmd=${agentCommand.join(" ")}`);
-    this.emit({ t: "session.created", info });
-    return info;
-  }
   async resume(idOrPrefix) {
     const stored = this.store.findByPrefix(idOrPrefix);
     if (!stored)
       throw new AxtermError("err.session.unknown", { id: idOrPrefix });
     if (this.live.has(stored.id))
       throw new AxtermError("err.session.running", { id: stored.shortId });
-    const storedAgent = agentIdFromCommand(stored.agentCommand);
-    if (storedAgent === "claude" || storedAgent === "gemini")
-      return this.resumeNamed(stored, storedAgent);
     const profile = agentProfile(agentIdFromCommand(stored.agentCommand));
-    const reference = resumeReference(profile, stored);
+    const reference = resumeReference(profile, { ...stored, ownSessionId: stored.id });
     if (reference === undefined) {
       throw new AxtermError("err.session.noConversation", {
         id: stored.shortId,
@@ -12268,7 +12556,7 @@ ${block}` : block);
     if (agentCommand === undefined) {
       throw new AxtermError("err.session.noResumeSupport", { agent: profile.displayName });
     }
-    if (!fs21.existsSync(stored.cwd))
+    if (!fs22.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const info = { ...stored, agentCommand, state: "running" };
     delete info.exitCode;
@@ -12276,8 +12564,7 @@ ${block}` : block);
     delete info.agentState;
     delete info.agentStateSource;
     const shell = resolveShell(info.shell);
-    const resumedAppServer = agentIdFromCommand(agentCommand) === "codex" ? await this.startCodexAppServer(info.id, this.ensureCodexHome(), info.cwd) : undefined;
-    await this.launch(info, shell, agentCommand, resumedAppServer);
+    await this.launch(info, shell, agentCommand);
     this.store.markResumed(info.id, agentCommand, info.ptyPid);
     log(`session ${info.shortId} resumed cmd=${agentCommand.join(" ")}`);
     this.emit({ t: "session.created", info });
@@ -12343,7 +12630,7 @@ ${block}` : block);
   removeScrollback(id) {
     for (const file of [`${id}.bin`, `${id}.bin.tmp`]) {
       try {
-        fs21.rmSync(path21.join(SCROLLBACK_DIR, file), { force: true });
+        fs22.rmSync(path21.join(SCROLLBACK_DIR, file), { force: true });
       } catch {}
     }
   }
@@ -12351,6 +12638,14 @@ ${block}` : block);
     this.drainGeminiTelemetry();
     this.watchForStalls();
   }
+  skipGeminiTelemetryHistory(id) {
+    const runtime = this.agentRuntime.get(id);
+    if (runtime === undefined)
+      return;
+    try {
+      runtime.telemetryOffset = fs22.statSync(this.geminiTelemetryPath(id)).size;
+    } catch {}
+  }
   drainGeminiTelemetry() {
     for (const [id, session] of this.live) {
       if (agentIdFromCommand(session.info.agentCommand) !== "gemini")
@@ -12361,7 +12656,7 @@ ${block}` : block);
       const file = this.geminiTelemetryPath(id);
       let size = 0;
       try {
-        size = fs21.statSync(file).size;
+        size = fs22.statSync(file).size;
       } catch {
         continue;
       }
@@ -12423,10 +12718,17 @@ ${block}` : block);
     clearInterval(this.sessionWatch);
     for (const id of [...this.codexServers.keys()])
       this.stopCodexAppServer(id);
-    for (const session of this.live.values()) {
+    let handedOn = 0;
+    for (const [id, session] of this.live) {
       session.saveScrollback();
+      if (this.hostOwned.has(id)) {
+        handedOn += 1;
+        continue;
+      }
       session.kill();
     }
+    if (handedOn > 0)
+      log(`left ${handedOn} session(s) running in the terminal host for the next daemon`);
     this.live.clear();
     this.agentRuntime.clear();
   }
@@ -12435,7 +12737,7 @@ var DEFAULT_COLS = 120, DEFAULT_ROWS = 30, MATERIALISED_DIR, ACTIVITY_ARG_CHARS
 var init_session_manager = __esm(() => {
   init_src();
   init_codex_home();
-  init_host_env();
+  init_session_env();
   init_git();
   init_claude_store();
   init_injector();
@@ -12481,6 +12783,9 @@ class FetchTelegramApi {
       throw new Error(`telegram file download failed: ${res.status}`);
     return new Uint8Array(await res.arrayBuffer());
   }
+  async deleteMessage(chatId, messageId) {
+    await this.call("deleteMessage", { chat_id: chatId, message_id: messageId });
+  }
   async call(method, params = {}) {
     const attempt = async () => {
       const res = await fetch(`https://api.telegram.org/bot${this.botToken}/${method}`, {
@@ -12599,11 +12904,11 @@ var init_acknowledge = __esm(() => {
 });
 
 // packages/channel-telegram/src/attach.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import path22 from "path";
 function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELEGRAM_LIMITS) {
   const name = path22.basename(filePath);
-  const bytes = fs22.statSync(filePath).size;
+  const bytes = fs23.statSync(filePath).size;
   const plan = planAttachment({ name, bytes }, limits);
   if (plan.kind === "rejected")
     throw new Error(plan.reason);
@@ -12613,7 +12918,7 @@ function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELE
   form.append("message_thread_id", String(topicId));
   if (caption !== undefined && caption.length > 0)
     form.append("caption", caption);
-  form.append(field, new Blob([fs22.readFileSync(filePath)]), name);
+  form.append(field, new Blob([fs23.readFileSync(filePath)]), name);
   return { method: plan.kind === "photo" ? "sendPhoto" : "sendDocument", field, form };
 }
 function isPhotoRejection(error) {
@@ -12627,7 +12932,7 @@ function asDocumentUpload(filePath, chatId, topicId, caption) {
   form.append("message_thread_id", String(topicId));
   if (caption !== undefined && caption.length > 0)
     form.append("caption", caption);
-  form.append("document", new Blob([fs22.readFileSync(filePath)]), name);
+  form.append("document", new Blob([fs23.readFileSync(filePath)]), name);
   return { method: "sendDocument", field: "document", form };
 }
 var TELEGRAM_LIMITS;
@@ -13523,6 +13828,26 @@ ${code(prompt.line)}`,
     });
   }
   awaitingSecret = new Map;
+  async captureSecret(sessionId, msg, text) {
+    const seq = this.awaitingSecret.get(sessionId);
+    if (seq === undefined)
+      return false;
+    this.awaitingSecret.delete(sessionId);
+    const accepted = this.control.answerShellPrompt(sessionId, seq, text);
+    let deleted = false;
+    if (this.api.deleteMessage && msg.chat && msg.message_id !== undefined) {
+      try {
+        await this.api.deleteMessage(msg.chat.id, msg.message_id);
+        deleted = true;
+      } catch (err) {
+        this.log(`secret reply message ${msg.message_id} not deleted: ${String(err)}`);
+      }
+    }
+    await this.sendToSession(sessionId, tHtml(accepted ? "tg.prompt.secretSubmitted" : "tg.prompt.secretStale"));
+    if (!deleted)
+      await this.sendToSession(sessionId, tHtml("tg.prompt.secretUndeleted"));
+    return true;
+  }
   async onChoiceRequest(sessionId, seq, questions, askId, onboarding2 = false) {
     const binding = this.control.findBindingBySession(sessionId);
     if (!binding || questions.length === 0)
@@ -13686,6 +14011,8 @@ ${code(prompt.line)}`,
     }
     if (!binding)
       return;
+    if (await this.captureSecret(binding.sessionId, msg, text))
+      return;
     if (await this.captureFreeText(binding.sessionId, text))
       return;
     const chatId = msg.chat.id;
@@ -13916,8 +14243,15 @@ ${code(prompt.line)}`,
         const project = await resolveProject(args[0]);
         if (!project)
           return;
-        const name = args.slice(1).join(" ") || undefined;
-        await this.control.createSession({ cwd: project.path, ...name !== undefined ? { name } : {} });
+        const tail = args.slice(1);
+        const flagAt = tail.findIndex((token) => token.startsWith("-"));
+        const name = (flagAt < 0 ? tail : tail.slice(0, flagAt)).join(" ") || undefined;
+        const agentArgs = flagAt < 0 ? [] : tail.slice(flagAt);
+        await this.control.createSession({
+          cwd: project.path,
+          ...name !== undefined ? { name } : {},
+          ...agentArgs.length > 0 ? { agentArgs } : {}
+        });
         return;
       }
       case "/wt": {
@@ -14205,13 +14539,15 @@ class TelegramService {
   config;
   store;
   manager;
+  apiFactory;
   channel;
   unsubscribe;
   runningConfig;
-  constructor(config, store, manager) {
+  constructor(config, store, manager, apiFactory = (token) => new FetchTelegramApi(token)) {
     this.config = config;
     this.store = store;
     this.manager = manager;
+    this.apiFactory = apiFactory;
   }
   readSettings() {
     const telegram = this.config.resolved().channels.telegram;
@@ -14260,7 +14596,7 @@ class TelegramService {
     const token = botToken ?? this.readSettings().botToken;
     if (!token)
       throw new AxtermError("err.telegram.noToken");
-    const api = new FetchTelegramApi(token);
+    const api = this.apiFactory(token);
     const updates = await api.call("getUpdates", { timeout: 0 });
     return discoverTelegramTargets(updates);
   }
@@ -14275,7 +14611,7 @@ class TelegramService {
       log("telegram: not configured, channel not started");
       return false;
     }
-    const api = new FetchTelegramApi(s.botToken);
+    const api = this.apiFactory(s.botToken);
     const config = {
       groupId: s.groupId,
       allowedUserIds: [s.allowUserId],
@@ -14423,7 +14759,7 @@ var init_telegram_service = __esm(() => {
 // packages/daemon/src/index.ts
 var exports_src = {};
 import { randomBytes as randomBytes3 } from "crypto";
-import fs23 from "fs";
+import fs24 from "fs";
 import net5 from "net";
 function isPidAlive(pid) {
   try {
@@ -14435,9 +14771,9 @@ function isPidAlive(pid) {
 }
 async function main() {
   ensureDataDirs();
-  if (fs23.existsSync(RUNTIME_FILE2)) {
+  if (fs24.existsSync(RUNTIME_FILE2)) {
     try {
-      const existing = JSON.parse(fs23.readFileSync(RUNTIME_FILE2, "utf8"));
+      const existing = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
       if (existing.pid !== process.pid && isPidAlive(existing.pid)) {
         log(`daemon already running (pid ${existing.pid}); exiting`);
         process.exit(0);
@@ -14460,7 +14796,7 @@ async function main() {
     version: productVersion(),
     startedAt: Date.now()
   };
-  fs23.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
+  fs24.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
   restrictFile(RUNTIME_FILE2);
   const config = new ConfigStore(defaultConfigStorePaths(CONFIG_DIR));
   if (config.loadError !== undefined)
@@ -14512,12 +14848,15 @@ async function main() {
     hookHost.stop();
     store.close();
     try {
-      const current = JSON.parse(fs23.readFileSync(RUNTIME_FILE2, "utf8"));
+      const current = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
       if (current.pid === process.pid)
-        fs23.rmSync(RUNTIME_FILE2);
+        fs24.rmSync(RUNTIME_FILE2);
     } catch {}
     process.exit(0);
   };
+  const recovered = await manager.recover();
+  if (recovered.adopted > 0)
+    log(`boot: ${recovered.adopted} session(s) adopted from the terminal host`);
   startRpcServer({
     pipePath: PIPE_PATH,
     token,
@@ -14603,7 +14942,7 @@ function startPtyHost(options) {
           send(socket, {
             t: "welcome",
             v: PTY_PROTOCOL_VERSION,
-            sessions: [...sessions.entries()].filter(([, s]) => !s.exited).map(([id, s]) => ({ id, pid: s.handle.pid }))
+            sessions: [...sessions.entries()].filter(([, s]) => !s.exited).map(([id, s]) => ({ id, pid: s.handle.pid, cols: s.cols, rows: s.rows }))
           });
           continue;
         }
@@ -14620,9 +14959,18 @@ function startPtyHost(options) {
               env: message.env,
               term: message.term
             });
-            const session = { handle, cols: message.cols, rows: message.rows, exited: false };
+            const session = {
+              handle,
+              cols: message.cols,
+              rows: message.rows,
+              exited: false,
+              mirror: new TerminalMirror(message.cols, message.rows, REPLAY_SCROLLBACK_LINES)
+            };
             sessions.set(message.id, session);
-            handle.onData((text) => broadcast(encodeFrame(FrameKind.Data, message.id, new TextEncoder().encode(text))));
+            handle.onData((text) => {
+              session.mirror.write(text);
+              broadcast(encodeFrame(FrameKind.Data, message.id, new TextEncoder().encode(text)));
+            });
             handle.onExit((code2) => {
               session.exited = true;
               for (const client of clients)
@@ -14637,6 +14985,21 @@ function startPtyHost(options) {
           }
           continue;
         }
+        if (message.t === "subscribe") {
+          const session = sessions.get(message.id);
+          if (session === undefined) {
+            send(socket, { t: "error", id: message.id, message: "no such session" });
+            continue;
+          }
+          if (message.replay) {
+            const ansi = session.mirror.serialize(REPLAY_MAX_CHARS);
+            if (ansi.length > 0 && !socket.destroyed) {
+              socket.write(encodeFrame(FrameKind.Data, message.id, new TextEncoder().encode(ansi)));
+            }
+          }
+          send(socket, { t: "subscribed", id: message.id });
+          continue;
+        }
         if (message.t === "resize") {
           const session = sessions.get(message.id);
           if (session === undefined || session.exited)
@@ -14644,6 +15007,7 @@ function startPtyHost(options) {
           session.cols = message.cols;
           session.rows = message.rows;
           session.handle.resize(message.cols, message.rows);
+          session.mirror.resize(message.cols, message.rows);
           continue;
         }
         if (message.t === "kill") {
@@ -14674,10 +15038,13 @@ function startPtyHost(options) {
     });
   });
 }
+var REPLAY_MAX_CHARS, REPLAY_SCROLLBACK_LINES = 5000;
 var init_pty_host = __esm(() => {
   init_src();
   init_paths();
   init_pty();
+  init_terminal_mirror();
+  REPLAY_MAX_CHARS = 2 * 1024 * 1024;
 });
 
 // packages/daemon/src/pty-host-main.ts
@@ -14730,7 +15097,7 @@ var init_pty_host_main = __esm(() => {
 
 // packages/cli/src/index.ts
 init_src();
-import fs24 from "fs";
+import fs25 from "fs";
 import path23 from "path";
 
 // packages/cli/src/attach.ts
@@ -15333,6 +15700,7 @@ async function ensureDaemon() {
 
 // packages/cli/src/hook-bridge.ts
 init_src();
+import fs3 from "fs";
 var POST_TIMEOUT_MS = 1500;
 function isCodexApproval(agent, body) {
   if (agent !== "codex")
@@ -15357,23 +15725,43 @@ async function relayHookEvent(agent) {
     if (body === "")
       return;
     const approval = isCodexApproval(agent, body);
-    const res = await fetch(target.url, {
-      method: "POST",
-      headers: target.headers,
-      body,
-      signal: AbortSignal.timeout(approval ? CODEX_APPROVAL_POST_TIMEOUT_MS : POST_TIMEOUT_MS)
-    });
-    if (approval && res.ok) {
+    const timeout = approval ? CODEX_APPROVAL_POST_TIMEOUT_MS : POST_TIMEOUT_MS;
+    const post = (to) => fetch(to.url, { method: "POST", headers: to.headers, body, signal: AbortSignal.timeout(timeout) });
+    let res;
+    try {
+      res = await post(target);
+    } catch {}
+    if (res === undefined || res.status === 401 || res.status === 404) {
+      if (approval && res === undefined)
+        return;
+      const fresh = currentEndpoint();
+      const retarget = fresh === undefined ? undefined : hookPostTarget(process.env, agent, fresh);
+      if (retarget !== undefined && retarget.url !== target.url)
+        res = await post(retarget);
+      else if (res === undefined)
+        return;
+    }
+    if (approval && res !== undefined && res.ok) {
       const decision = await res.text();
       if (decision !== "")
         process.stdout.write(decision);
     }
   } catch {}
 }
+function currentEndpoint() {
+  const file = process.env["AXTERM_HOOK_ENDPOINT"];
+  if (file === undefined)
+    return;
+  try {
+    return parseHookEndpoint(fs3.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
 
 // packages/cli/src/mcp-server.ts
 init_src();
-import fs3 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 var ASK_TIMEOUT_MS = 10 * 60000;
 var POST_TIMEOUT_MS2 = 5000;
@@ -15490,7 +15878,7 @@ class McpServer {
     const contextFile = this.io.env[MCP_CONTEXT_ENV];
     if (contextFile !== undefined) {
       try {
-        const context = JSON.parse(fs3.readFileSync(contextFile, "utf8"));
+        const context = JSON.parse(fs4.readFileSync(contextFile, "utf8"));
         if (context.port && context.token && context.sessionId) {
           return {
             url: `http://127.0.0.1:${context.port}`,
@@ -15647,13 +16035,13 @@ function runMcpServer() {
 init_src();
 import { spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 // packages/cli/package.json
 var package_default = {
   name: "@layorixinc/axterm",
-  version: "0.5.0",
+  version: "0.6.0",
   type: "module",
   bin: {
     axterm: "dist/cli.js"
@@ -15727,7 +16115,7 @@ function assetName(platform, arch, isMusl) {
 function usesMusl() {
   if (process.platform !== "linux")
     return false;
-  if (fs4.existsSync("/etc/alpine-release"))
+  if (fs5.existsSync("/etc/alpine-release"))
     return true;
   const ldd = spawnSync("ldd", ["--version"], { encoding: "utf8" });
   return `${ldd.stdout ?? ""}${ldd.stderr ?? ""}`.toLowerCase().includes("musl");
@@ -15741,7 +16129,7 @@ function firstLine(command, args) {
 function detectOrigin(execPath) {
   const resolved = (() => {
     try {
-      return fs4.realpathSync(execPath);
+      return fs5.realpathSync(execPath);
     } catch {
       return execPath;
     }
@@ -15783,7 +16171,7 @@ function checksumFor(sums, asset) {
   return;
 }
 function sha256(file) {
-  return createHash2("sha256").update(fs4.readFileSync(file)).digest("hex");
+  return createHash2("sha256").update(fs5.readFileSync(file)).digest("hex");
 }
 function ask2(question) {
   if (stdin2.isTTY !== true)
@@ -15830,7 +16218,7 @@ async function runUpdate(client, current, options) {
   }
   const asset = assetName(process.platform, process.arch, usesMusl());
   const base = `${RELEASES}/v${latest.version}`;
-  const staging = fs4.mkdtempSync(`${process.execPath}.update-`);
+  const staging = fs5.mkdtempSync(`${process.execPath}.update-`);
   const downloaded = path5.join(staging, asset);
   try {
     console.log(t("cli.update.downloading", { asset }));
@@ -15844,7 +16232,7 @@ async function runUpdate(client, current, options) {
       return;
     }
     if (process.platform !== "win32")
-      fs4.chmodSync(downloaded, 493);
+      fs5.chmodSync(downloaded, 493);
     const reported = spawnSync(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
     if (reported !== latest.version) {
       console.error(t("cli.update.wrongVersion", { got: reported ?? "nothing", want: latest.version }));
@@ -15884,7 +16272,7 @@ async function runUpdate(client, current, options) {
         console.log(t("cli.update.restoreFailed", { id, reason: (result.stderr ?? "").trim() || "unknown" }));
     }
   } finally {
-    fs4.rmSync(staging, { recursive: true, force: true });
+    fs5.rmSync(staging, { recursive: true, force: true });
   }
 }
 function applySwap(target, downloaded) {
@@ -15893,16 +16281,16 @@ function applySwap(target, downloaded) {
   try {
     for (const step of steps) {
       if (step.op === "chmod")
-        fs4.chmodSync(step.from, 493);
+        fs5.chmodSync(step.from, 493);
       else if (step.op === "backup") {
-        fs4.renameSync(step.from, step.to);
+        fs5.renameSync(step.from, step.to);
         backup = step.to;
       } else
-        fs4.renameSync(step.from, step.to);
+        fs5.renameSync(step.from, step.to);
     }
   } catch (err) {
-    if (backup !== undefined && !fs4.existsSync(target))
-      fs4.renameSync(backup, target);
+    if (backup !== undefined && !fs5.existsSync(target))
+      fs5.renameSync(backup, target);
     throw err;
   }
 }
@@ -15975,7 +16363,7 @@ function printSessionTable(sessions) {
     console.log(row.map((cell, col) => cell.padEnd(widths[col])).join("  "));
   }
 }
-var realPath = (target) => fs24.realpathSync.native(target);
+var realPath = (target) => fs25.realpathSync.native(target);
 function scopedHere(sessions) {
   return sessionsInScope(sessions, process.cwd(), realPath);
 }
@@ -15988,7 +16376,7 @@ var help = () => t("cli.help");
 function readDotEnv(file = ".env") {
   const out = {};
   try {
-    for (const line of fs24.readFileSync(file, "utf8").split(/\r?\n/)) {
+    for (const line of fs25.readFileSync(file, "utf8").split(/\r?\n/)) {
       const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m)
         out[m[1]] = m[2].trim();
@@ -15999,7 +16387,7 @@ function readDotEnv(file = ".env") {
 function configuredLocale() {
   try {
     const file = resolvePaths(currentPathEnv()).configFile;
-    const raw = JSON.parse(fs24.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs25.readFileSync(file, "utf8"));
     return typeof raw.locale === "string" ? raw.locale : undefined;
   } catch {
     return;
@@ -16055,6 +16443,7 @@ async function main2() {
         const commandOverride = typeof flags.get("cmd") === "string" ? flags.get("cmd").split(/\s+/).filter(Boolean) : undefined;
         const info = await client.call("session.create", {
           cwd: flags.get("cwd") ?? process.cwd(),
+          preferConversationCwd: flags.get("cwd") === undefined,
           name: flags.get("name"),
           shell: flags.get("shell"),
           agent: flags.get("agent"),
@@ -16148,9 +16537,17 @@ async function main2() {
         const [id, indexArg] = positional;
         if (!id || indexArg === undefined)
           throw new Error(t("cli.usage.choose"));
-        const keys2 = buildMenuSelectKeys(Number(indexArg));
-        await client.call("terminal.write", { id, dataB64: Buffer.from(keys2, "utf8").toString("base64") });
+        const index = Number(indexArg);
+        const answered = await client.call("session.choose", { id, index }).catch(async (err) => {
+          if (!/unknown method/i.test(String(err)))
+            throw err;
+          const keys2 = buildMenuSelectKeys(index);
+          await client.call("terminal.write", { id, dataB64: Buffer.from(keys2, "utf8").toString("base64") });
+          return { answered: "menu" };
+        });
         console.log(t("cli.session.selected", { index: indexArg }));
+        if (answered.answered === "onboarding")
+          console.log(t("cli.session.selectedDialog"));
         break;
       }
       case "setup": {