@layorixinc/axterm 0.5.0 → 0.6.1

package/dist/cli.js

@@ -46,6 +46,179 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/core/src/menu-keys.ts
+function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
+  if (!Number.isInteger(index) || index < 0) {
+    throw new RangeError(`menu index must be a non-negative integer, got ${index}`);
+  }
+  return MENU_UP.repeat(normalizePresses) + MENU_DOWN.repeat(index) + MENU_SELECT;
+}
+var MENU_UP = "\x1B[A", MENU_DOWN = "\x1B[B", MENU_SELECT = "\r", MENU_NORMALIZE_PRESSES = 24;
+
+// 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 menuChoiceKeys(profile, optionIndex) {
+  const keys = profile.approvalKeys;
+  if (keys !== undefined) {
+    return optionIndex === 0 ? keys.allow : optionIndex === 1 ? keys.deny : undefined;
+  }
+  return profile.clampingApprovalMenu === true ? buildMenuSelectKeys(optionIndex) : undefined;
+}
+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",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
+      hostHookSource: "omp",
+      clampingApprovalMenu: true,
+      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"],
+      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
+      structuredApprovals: true,
+      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 +249,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 +263,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 +279,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 +323,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"];
 });
 
@@ -917,6 +1036,7 @@ usage:
   axterm rm <id\u2026> [--force]        forget a session: its row, scrollback and topic binding
   axterm rm --exited [--all]        forget every exited session this listing would show
   axterm daemon status|stop
+  axterm service install|status|uninstall   start at login and restart daemon failures
   axterm project add <dir> [alias] | list | rm <alias>   register a project for channel use
   axterm run [--worktree BRANCH] [--base REF] ...   worktree-backed session
   axterm fanout --count 3 [--prefix try] "prompt"
@@ -944,6 +1064,8 @@ 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.choose.daemonTooOld": "this daemon is too old to answer a dialog safely \u2014 its `choose` sent keystrokes that land on the row below on claude and gemini, which is a wider grant. Restart the daemon, or send the keys yourself with `axterm key`",
     "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})",
@@ -987,6 +1109,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.usage.worktree": "usage: axterm worktree list|rm <branch> [--force]",
     "cli.usage.worktreeRm": "usage: axterm worktree rm <branch> [--force]",
     "cli.usage.daemon": "usage: axterm daemon status|stop",
+    "cli.usage.service": "usage: axterm service install|status|uninstall",
     "cli.usage.telegram": "usage: axterm telegram link|doctor|status|discover",
     "cli.usage.fanout": "usage: axterm fanout --count N <prompt>",
     "cli.config.set": "set {path}",
@@ -1003,6 +1126,13 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.worktree.refused": "refused: {reason}",
     "cli.daemon.stopping": "daemon stopping",
     "cli.daemon.notReady": "daemon did not become ready within 15s (see {log})",
+    "cli.service.installed": "installed {kind} service; the daemon is running under the supervisor",
+    "cli.service.uninstalled": "removed service registration; the current daemon keeps running",
+    "cli.service.status": "service: {kind}; installed={installed}; active={active}",
+    "cli.service.yes": "yes",
+    "cli.service.no": "no",
+    "cli.service.commandFailed": "service command failed ({command}): {error}",
+    "cli.service.notReady": "the service started but the daemon was not ready within 15s",
     "cli.telegram.missingSettings": "telegram link: no token/group/user found. Provide --token/--group/--user flags, TELEGRAM_* environment variables, or a .env file in the current directory.",
     "cli.telegram.discoverHint": "Create a group with Topics enabled, add your bot to it, then run this again. Being added is enough \u2014 you do not have to send anything.",
     "cli.telegram.discoverNone": "the bot cannot see any group yet.",
@@ -1013,7 +1143,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]",
@@ -1033,8 +1163,13 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.status.inferred": "\u2139\uFE0F Guessed from what is running under the shell \u2014 this agent reports nothing, so there are no approval buttons or replies here (axterm attach shows everything).",
     "tg.session.emptyScreen": "(empty screen)",
     "tg.prompt.confirm": "the session is waiting on a confirmation:",
+    "tg.poll.conflict": "\u26A0\uFE0F {machine} cannot receive messages: another axterm is polling this bot token, and Telegram allows only one. Stop the other instance, or give this machine its own bot.",
+    "tg.poll.failed": "\u26A0\uFE0F {machine} cannot receive messages right now: {reason}",
     "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}",
@@ -1079,6 +1214,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.answer.pickAtLeastOne": "pick at least one",
     "tg.answer.confirmed": "confirmed",
     "tg.answer.unknownOption": "no such option",
+    "tg.answer.noSafeKey": "axterm cannot press this row safely \u2014 use /key or /type",
     "tg.answer.picked": "{label} selected",
     "tg.answer.toggledOn": "{label} selected",
     "tg.answer.toggledOff": "{label} cleared",
@@ -1127,6 +1263,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.codex.trustStale": "codex hooks: {stale}/{total} trust hashes stale \u2014 codex reports them Modified and silently skips them; re-grant via /hooks in the codex TUI",
     "doctor.codex.trustPending": "codex hooks: {pending}/{total} not yet granted \u2014 appended at the next codex launch",
     "doctor.telegram.ok": "telegram: connected",
+    "doctor.telegram.pollFailing": "telegram cannot receive: {reason}",
     "doctor.telegram.off": "telegram: not running",
     "doctor.telegram.problems": "telegram: {problems}",
     "quota.gauge": "{agent}: {percent}% of {window} used, resets in {resets}",
@@ -1152,10 +1289,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.session.dialogOpen": "session {id} is waiting on a dialog ({state}); answer it with the buttons or /esc first",
     "err.agent.notInstalled": "the agent command '{command}' was not found on PATH \u2014 install it, or pass --cmd to run something else",
     "err.agent.unknown": "unknown agent '{agent}' \u2014 supported: {supported}",
+    "err.choose.noSafeKey": "axterm cannot select row {index} of a {agent} dialog: its menu wraps, so an absolute row cannot be addressed from an unknown cursor position \u2014 use `axterm key` for the keys you want",
     "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",
+    "agent.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",
     "err.codex.authLink": "could not link codex credentials into axterm's CODEX_HOME ({reason}) \u2014 refusing to start a logged-out agent",
     "health.config.invalid": "the configuration file could not be understood",
@@ -1218,6 +1357,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
   axterm rm <id\u2026> [--force]        \uC138\uC158\uC744 \uC78A\uB294\uB2E4: \uBAA9\uB85D\xB7\uC2A4\uD06C\uB864\uBC31\xB7\uD1A0\uD53D \uC5F0\uACB0\uAE4C\uC9C0
   axterm rm --exited [--all]        \uC774 \uBAA9\uB85D\uC5D0 \uBCF4\uC774\uB294 \uC885\uB8CC\uB41C \uC138\uC158\uC744 \uBAA8\uB450 \uC78A\uB294\uB2E4
   axterm daemon status|stop
+  axterm service install|status|uninstall   \uB85C\uADF8\uC778 \uC2DC \uC2DC\uC791\uD558\uACE0 \uB370\uBAAC \uC2E4\uD328 \uC2DC \uC7AC\uC2DC\uC791
   axterm project add <\uD3F4\uB354> [\uBCC4\uCE6D] | list | rm <\uBCC4\uCE6D>   \uCC44\uB110\uC5D0\uC11C \uC4F8 \uD504\uB85C\uC81D\uD2B8 \uB4F1\uB85D
   axterm run [--worktree \uBE0C\uB79C\uCE58] [--base REF] ...   worktree \uAE30\uBC18 \uC138\uC158
   axterm fanout --count 3 [--prefix try] "\uD504\uB86C\uD504\uD2B8"
@@ -1245,6 +1385,8 @@ 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.choose.daemonTooOld": "\uC774 \uB370\uBAAC\uC740 \uB300\uD654\uC0C1\uC790\uB97C \uC548\uC804\uD558\uAC8C \uC751\uB2F5\uD560 \uC218 \uC5C6\uB294 \uAD6C\uBC84\uC804\uC785\uB2C8\uB2E4. \uC608\uC804 `choose` \uB294 claude \uC640 gemini \uC5D0\uC11C \uD55C \uD589 \uC544\uB798\uB97C \uC120\uD0DD\uD588\uACE0 \uADF8\uAC83\uC740 \uB354 \uB113\uC740 \uC2B9\uC778\uC785\uB2C8\uB2E4. \uB370\uBAAC\uC744 \uC7AC\uC2DC\uC791\uD558\uAC70\uB098 `axterm key` \uB85C \uC9C1\uC811 \uD0A4\uB97C \uBCF4\uB0B4\uC138\uC694",
     "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})",
@@ -1288,6 +1430,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.usage.worktree": "\uC0AC\uC6A9\uBC95: axterm worktree list|rm <\uBE0C\uB79C\uCE58> [--force]",
     "cli.usage.worktreeRm": "\uC0AC\uC6A9\uBC95: axterm worktree rm <\uBE0C\uB79C\uCE58> [--force]",
     "cli.usage.daemon": "\uC0AC\uC6A9\uBC95: axterm daemon status|stop",
+    "cli.usage.service": "\uC0AC\uC6A9\uBC95: axterm service install|status|uninstall",
     "cli.usage.telegram": "\uC0AC\uC6A9\uBC95: axterm telegram link|doctor|status|discover",
     "cli.usage.fanout": "\uC0AC\uC6A9\uBC95: axterm fanout --count N <\uD504\uB86C\uD504\uD2B8>",
     "cli.config.set": "{path} \uC124\uC815\uB428",
@@ -1304,10 +1447,17 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.worktree.refused": "\uAC70\uBD80\uB428: {reason}",
     "cli.daemon.stopping": "\uB370\uBAAC \uC885\uB8CC \uC911",
     "cli.daemon.notReady": "15\uCD08 \uC548\uC5D0 \uB370\uBAAC\uC774 \uC900\uBE44\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4 ({log} \uD655\uC778)",
+    "cli.service.installed": "{kind} \uC11C\uBE44\uC2A4 \uC124\uCE58\uB428. \uB370\uBAAC\uC740 supervisor \uC544\uB798\uC5D0\uC11C \uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4",
+    "cli.service.uninstalled": "\uC11C\uBE44\uC2A4 \uB4F1\uB85D\uC744 \uC81C\uAC70\uD588\uC2B5\uB2C8\uB2E4. \uD604\uC7AC \uB370\uBAAC\uC740 \uACC4\uC18D \uC2E4\uD589\uB429\uB2C8\uB2E4",
+    "cli.service.status": "\uC11C\uBE44\uC2A4: {kind}; \uC124\uCE58={installed}; \uD65C\uC131={active}",
+    "cli.service.yes": "\uC608",
+    "cli.service.no": "\uC544\uB2C8\uC694",
+    "cli.service.commandFailed": "\uC11C\uBE44\uC2A4 \uBA85\uB839 \uC2E4\uD328 ({command}): {error}",
+    "cli.service.notReady": "\uC11C\uBE44\uC2A4\uAC00 \uC2DC\uC791\uB410\uC9C0\uB9CC 15\uCD08 \uC548\uC5D0 \uB370\uBAAC\uC774 \uC900\uBE44\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4",
     "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]",
@@ -1334,8 +1484,13 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.status.inferred": "\u2139\uFE0F \uC178\uC5D0\uC11C \uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4\uB85C \uCD94\uC815\uD55C \uC0C1\uD0DC\uC785\uB2C8\uB2E4 \u2014 \uC774 \uC5D0\uC774\uC804\uD2B8\uB294 \uC0C1\uD0DC\uB97C \uBCF4\uACE0\uD558\uC9C0 \uC54A\uC544 \uC2B9\uC778 \uBC84\uD2BC\uB3C4, \uB2F5\uBCC0\uB3C4 \uC5C6\uC2B5\uB2C8\uB2E4 (\uC804\uCCB4\uB294 axterm attach\uB85C \uD655\uC778\uD558\uC138\uC694).",
     "tg.session.emptyScreen": "(\uBE48 \uD654\uBA74)",
     "tg.prompt.confirm": "\uC138\uC158\uC774 \uD655\uC778\uC744 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4:",
+    "tg.poll.conflict": "\u26A0\uFE0F {machine} \uC774 \uBA54\uC2DC\uC9C0\uB97C \uBC1B\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: \uB2E4\uB978 axterm \uC774 \uC774 \uBD07 \uD1A0\uD070\uC744 \uD3F4\uB9C1\uD558\uACE0 \uC788\uACE0 Telegram \uC740 \uD558\uB098\uB9CC \uD5C8\uC6A9\uD569\uB2C8\uB2E4. \uB2E4\uB978 \uC778\uC2A4\uD134\uC2A4\uB97C \uB044\uAC70\uB098 \uC774 \uBA38\uC2E0\uC5D0 \uC804\uC6A9 \uBD07\uC744 \uC8FC\uC138\uC694.",
+    "tg.poll.failed": "\u26A0\uFE0F {machine} \uC774 \uC9C0\uAE08 \uBA54\uC2DC\uC9C0\uB97C \uBC1B\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: {reason}",
     "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}",
@@ -1380,6 +1535,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.answer.pickAtLeastOne": "\uCD5C\uC18C 1\uAC1C\uB294 \uC120\uD0DD\uD558\uC138\uC694",
     "tg.answer.confirmed": "\uD655\uC815\uB428",
     "tg.answer.unknownOption": "\uC5C6\uB294 \uC120\uD0DD\uC9C0",
+    "tg.answer.noSafeKey": "\uC774 \uD589\uC740 \uC548\uC804\uD558\uAC8C \uB204\uB97C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 /key \uB610\uB294 /type\uC744 \uC4F0\uC138\uC694",
     "tg.answer.picked": "{label} \uC120\uD0DD\uB428",
     "tg.answer.toggledOn": "{label} \uC120\uD0DD",
     "tg.answer.toggledOff": "{label} \uD574\uC81C",
@@ -1428,6 +1584,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.codex.trustStale": "codex \uD6C5: {stale}/{total} \uC2E0\uB8B0 \uD574\uC2DC \uBD88\uC77C\uCE58 \u2014 codex\uAC00 Modified\uB85C \uBCF4\uACE0\uD558\uACE0 \uC870\uC6A9\uD788 \uAC74\uB108\uB701\uB2C8\uB2E4; codex TUI\uC758 /hooks\uC5D0\uC11C \uC7AC\uC2B9\uC778\uD558\uC138\uC694",
     "doctor.codex.trustPending": "codex \uD6C5: {pending}/{total} \uBBF8\uC2B9\uC778 \u2014 \uB2E4\uC74C codex \uC2E4\uD589 \uC2DC \uAE30\uB85D\uB429\uB2C8\uB2E4",
     "doctor.telegram.ok": "\uD154\uB808\uADF8\uB7A8: \uC5F0\uACB0\uB428",
+    "doctor.telegram.pollFailing": "\uD154\uB808\uADF8\uB7A8 \uC218\uC2E0 \uBD88\uAC00: {reason}",
     "doctor.telegram.off": "\uD154\uB808\uADF8\uB7A8: \uBBF8\uC2E4\uD589",
     "doctor.telegram.problems": "\uD154\uB808\uADF8\uB7A8: {problems}",
     "quota.gauge": "{agent}: {window} \uD55C\uB3C4\uC758 {percent}% \uC0AC\uC6A9, {resets} \uD6C4 \uCD08\uAE30\uD654",
@@ -1453,10 +1610,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.session.dialogOpen": "\uC138\uC158 {id} \uC774(\uAC00) \uB2E4\uC774\uC5BC\uB85C\uADF8\uB97C \uAE30\uB2E4\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4 ({state}). \uBC84\uD2BC\uC73C\uB85C \uB2F5\uD558\uAC70\uB098 /esc \uB97C \uBA3C\uC800 \uBCF4\uB0B4\uC138\uC694",
     "err.agent.notInstalled": "\uC5D0\uC774\uC804\uD2B8 \uBA85\uB839 '{command}' \uC744(\uB97C) PATH \uC5D0\uC11C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC124\uCE58\uD558\uAC70\uB098 --cmd \uB85C \uB2E4\uB978 \uBA85\uB839\uC744 \uC9C0\uC815\uD558\uC138\uC694",
     "err.agent.unknown": "\uC54C \uC218 \uC5C6\uB294 \uC5D0\uC774\uC804\uD2B8 '{agent}' \uC785\uB2C8\uB2E4. \uC9C0\uC6D0: {supported}",
+    "err.choose.noSafeKey": "{agent} \uB300\uD654\uC0C1\uC790\uC758 {index}\uBC88 \uD589\uC740 \uC120\uD0DD\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA54\uB274\uAC00 \uC21C\uD658\uD558\uBBC0\uB85C \uCEE4\uC11C \uC704\uCE58\uB97C \uBAA8\uB974\uB294 \uC0C1\uD0DC\uC5D0\uC11C \uC808\uB300 \uD589\uC744 \uC9C0\uC815\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC6D0\uD558\uB294 \uD0A4\uB294 `axterm key`\uB85C \uBCF4\uB0B4\uC138\uC694",
     "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",
+    "agent.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",
     "err.codex.authLink": "codex \uC790\uACA9 \uC99D\uBA85\uC744 axterm\uC758 CODEX_HOME\uC5D0 \uC5F0\uACB0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 ({reason}). \uB85C\uADF8\uC544\uC6C3 \uC0C1\uD0DC\uC758 \uC5D0\uC774\uC804\uD2B8\uB294 \uC2DC\uC791\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
     "health.config.invalid": "\uC124\uC815 \uD30C\uC77C\uC744 \uC774\uD574\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
@@ -1645,144 +1804,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 +1840,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 +1885,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 +1904,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;
 }
@@ -1875,6 +1919,222 @@ var init_self_spawn = __esm(() => {
   RUNTIME_NAMES = new Set(["bun", "bun.exe", "bun-debug", "bun-debug.exe", "node", "node.exe"]);
 });
 
+// packages/core/src/service.ts
+import path2 from "path";
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdArgument(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("%", "%%")}"`;
+}
+function windowsArgument(value) {
+  if (value !== "" && !/[\s"]/u.test(value))
+    return value;
+  let out = '"';
+  let slashes = 0;
+  for (const char of value) {
+    if (char === "\\") {
+      slashes++;
+      continue;
+    }
+    if (char === '"') {
+      out += "\\".repeat(slashes * 2 + 1) + '"';
+      slashes = 0;
+      continue;
+    }
+    out += "\\".repeat(slashes) + char;
+    slashes = 0;
+  }
+  return out + "\\".repeat(slashes * 2) + '"';
+}
+function windowsCommandLine(args) {
+  return args.map(windowsArgument).join(" ");
+}
+function environmentEntries(input) {
+  return Object.entries(input.environment ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key))
+      throw new Error(`invalid service environment key: ${key}`);
+    if (/[\0\r\n]/u.test(value))
+      throw new Error(`invalid service environment value for ${key}`);
+    return [key, value];
+  });
+}
+function systemdEnvironment(input) {
+  return environmentEntries(input).map(([key, value]) => `Environment="${`${key}=${value}`.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("%", "%%")}"`).join(`
+`);
+}
+function launchdEnvironment(input) {
+  const entries = environmentEntries(input);
+  if (entries.length === 0)
+    return "";
+  return `  <key>EnvironmentVariables</key>
+  <dict>
+${entries.map(([key, value]) => `    <key>${xml(key)}</key>
+    <string>${xml(value)}</string>`).join(`
+`)}
+  </dict>
+`;
+}
+function systemdDefinition(input) {
+  const argv = [input.launch.command, ...input.launch.args].map(systemdArgument).join(" ");
+  const environment = systemdEnvironment(input);
+  return {
+    kind: "systemd",
+    id: SYSTEMD_SERVICE,
+    file: path2.posix.join(input.homeDir, ".config/systemd/user", SYSTEMD_SERVICE),
+    contents: `[Unit]
+Description=axterm daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=:${argv}
+${environment ? `${environment}
+` : ""}Restart=on-failure
+RestartSec=2
+TimeoutStopSec=20
+# The PTY host is detached but remains in this cgroup. Stop only the daemon.
+KillMode=process
+
+[Install]
+WantedBy=default.target
+`
+  };
+}
+function launchdDefinition(input) {
+  const argumentsXml = [input.launch.command, ...input.launch.args].map((arg) => `    <string>${xml(arg)}</string>`).join(`
+`);
+  const logFile = path2.posix.join(input.stateDir, "logs/service.log");
+  return {
+    kind: "launchd",
+    id: LAUNCHD_LABEL,
+    file: path2.posix.join(input.homeDir, "Library/LaunchAgents", `${LAUNCHD_LABEL}.plist`),
+    contents: `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argumentsXml}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xml(input.homeDir)}</string>
+${launchdEnvironment(input)}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>2</integer>
+  <key>AbandonProcessGroup</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(logFile)}</string>
+</dict>
+</plist>
+`
+  };
+}
+function powershellLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function taskDefinition(input) {
+  if (!input.userId)
+    throw new Error("Task Scheduler requires userId");
+  const entries = environmentEntries(input);
+  let command = input.launch.command;
+  let argumentsLine = windowsCommandLine(input.launch.args);
+  let companionFiles;
+  if (entries.length > 0) {
+    const wrapperFile = path2.win32.join(input.stateDir, "service", "axterm-service.ps1");
+    const environment = entries.map(([key, value]) => `$env:${key} = ${powershellLiteral(value)}`).join(`\r
+`);
+    const invocation = [input.launch.command, ...input.launch.args].map(powershellLiteral).join(" ");
+    companionFiles = [
+      {
+        file: wrapperFile,
+        contents: `$ErrorActionPreference = 'Stop'\r
+${environment}\r
+& ${invocation}\r
+exit $LASTEXITCODE\r
+`
+      }
+    ];
+    command = "powershell.exe";
+    argumentsLine = windowsCommandLine([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      wrapperFile
+    ]);
+  }
+  return {
+    kind: "task-scheduler",
+    id: WINDOWS_TASK,
+    file: path2.win32.join(input.stateDir, "service", "axterm-task.xml"),
+    contents: `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>axterm daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xml(input.userId)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xml(input.userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>false</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>255</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xml(command)}</Command>
+      <Arguments>${xml(argumentsLine)}</Arguments>
+      <WorkingDirectory>${xml(input.homeDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`,
+    ...companionFiles ? { companionFiles } : {}
+  };
+}
+function serviceDefinition(input) {
+  if (input.platform === "linux")
+    return systemdDefinition(input);
+  if (input.platform === "darwin")
+    return launchdDefinition(input);
+  if (input.platform === "win32")
+    return taskDefinition(input);
+  throw new Error(`service management is not supported on ${input.platform}`);
+}
+var SYSTEMD_SERVICE = "axterm.service", LAUNCHD_LABEL = "com.layorix.axterm.daemon", WINDOWS_TASK = "axterm-daemon";
+var init_service = () => {};
+
 // packages/core/src/attachment.ts
 function megabytes(bytes) {
   return `${Math.round(bytes / (1024 * 1024))} MB`;
@@ -1992,6 +2252,7 @@ function planUpdateRestart(input) {
 var SEMVER;
 var init_update = __esm(() => {
   init_agent_registry();
+  init_agent_resume();
   SEMVER = /^\d+\.\d+\.\d+/;
 });
 
@@ -2064,6 +2325,22 @@ function parseProjectRef(raw) {
     return { machine: text.slice(0, split), alias: text.slice(split + 1) };
   return { alias: text };
 }
+function parseCommandAddress(token) {
+  const at = token.indexOf("@");
+  if (at < 0)
+    return { command: token };
+  const target = token.slice(at + 1);
+  if (!/^[A-Za-z0-9_]+$/.test(target))
+    return { command: token };
+  return { command: token.slice(0, at), target };
+}
+function commandIsForBot(target, self) {
+  if (target === undefined)
+    return true;
+  if (self === undefined)
+    return false;
+  return target.toLowerCase() === self.toLowerCase();
+}
 var MAX_NAME_LENGTH = 32;
 
 // packages/core/src/fanout.ts
@@ -2173,6 +2450,9 @@ function buildApprovalQuestion(toolName) {
 function isModalState(state) {
   return state === "blocked" || state === "waiting";
 }
+function offersKeystrokeApproval(profile, state) {
+  return state === "blocked" && profile.structuredApprovals !== true;
+}
 function dialogTransition(nextState, dialogOpen) {
   if (isModalState(nextState))
     return { open: true, resolved: false };
@@ -2183,14 +2463,29 @@ function isPromptInjectable(state) {
 }
 var init_choice = () => {};
 
-// packages/core/src/menu-keys.ts
-function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
-  if (!Number.isInteger(index) || index < 0) {
-    throw new RangeError(`menu index must be a non-negative integer, got ${index}`);
-  }
-  return MENU_UP.repeat(normalizePresses) + MENU_DOWN.repeat(index) + MENU_SELECT;
+// 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}`;
+    });
+  });
 }
-var MENU_UP = "\x1B[A", MENU_DOWN = "\x1B[B", MENU_SELECT = "\r", MENU_NORMALIZE_PRESSES = 24;
 
 // packages/core/src/agent-status.ts
 function next(prev, state, now) {
@@ -2201,17 +2496,29 @@ function next(prev, state, now) {
     stateStartedAt: prev?.state === state ? prev.stateStartedAt : 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 +2685,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
@@ -2511,7 +2829,7 @@ function mapClaudeHook(input) {
   }
 }
 function buildClaudeSettings(input) {
-  const handler = {
+  const handler = (timeout) => ({
     type: "http",
     url: `http://127.0.0.1:${input.port}/hook/claude`,
     headers: {
@@ -2519,16 +2837,36 @@ function buildClaudeSettings(input) {
       "x-axterm-session": input.sessionId,
       "x-axterm-launch": input.launchToken
     },
-    timeout: HOOK_TIMEOUT_SECONDS
-  };
+    timeout
+  });
+  const observe = handler(HOOK_TIMEOUT_SECONDS);
   const hooks = {};
-  for (const event of TOOL_EVENTS)
-    hooks[event] = [{ matcher: "*", hooks: [handler] }];
+  for (const event of TOOL_EVENTS) {
+    const single = event === "PermissionRequest" ? handler(APPROVAL_TIMEOUT_SECONDS) : observe;
+    hooks[event] = [{ matcher: "*", hooks: [single] }];
+  }
   for (const event of PLAIN_EVENTS)
-    hooks[event] = [{ hooks: [handler] }];
+    hooks[event] = [{ hooks: [observe] }];
   return { hooks };
 }
-var MAX_RESULT_TEXT = 2000, HOOK_TIMEOUT_SECONDS = 5, TOOL_EVENTS, PLAIN_EVENTS;
+function hookPermissionDecision(question, answers, denyMessage) {
+  const picked = answers?.find((a) => a.questionIndex === 0)?.selected[0];
+  if (picked === undefined)
+    return;
+  if (picked === question.options[0]?.label) {
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
+  }
+  if (picked === question.options[1]?.label) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PermissionRequest",
+        decision: { behavior: "deny", ...denyMessage !== undefined ? { message: denyMessage } : {} }
+      }
+    };
+  }
+  return;
+}
+var MAX_RESULT_TEXT = 2000, HOOK_TIMEOUT_SECONDS = 5, APPROVAL_TIMEOUT_SECONDS = 120, APPROVAL_HOLD_MS = 110000, TOOL_EVENTS, PLAIN_EVENTS;
 var init_claude_hooks = __esm(() => {
   TOOL_EVENTS = ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest"];
   PLAIN_EVENTS = [
@@ -2554,18 +2892,25 @@ function detectOnboarding(agent, screen) {
     if (!dialog)
       continue;
     const options = [];
+    let lastOption = -1;
     const end = Math.min(lines.length, i + 1 + OPTION_WINDOW_LINES + 1);
     for (let j = i + 1;j < end; j++) {
       const row = OPTION_ROW.exec(lines[j]);
-      if (row)
+      if (row) {
         options.push({ digit: row[1], label: row[2].trim() });
+        lastOption = j;
+      }
     }
-    if (options.length >= 2)
-      return { kind: dialog.kind, question: dialog.question, options };
+    if (options.length < 2)
+      continue;
+    const noise = lines.slice(lastOption + 1).filter((row) => row !== "" && !DIALOG_FOOTER.test(row));
+    if (noise.length > QUIET_AFTER_OPTIONS)
+      continue;
+    return { kind: dialog.kind, question: dialog.question, options };
   }
   return;
 }
-var DIALOGS, OPTION_ROW, OPTION_WINDOW_LINES = 8;
+var DIALOGS, OPTION_ROW, OPTION_WINDOW_LINES = 8, QUIET_AFTER_OPTIONS = 3, DIALOG_FOOTER;
 var init_onboarding = __esm(() => {
   DIALOGS = {
     gemini: [
@@ -2573,12 +2918,105 @@ 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:" }
     ],
     codex: [{ kind: "folderTrust", question: "Do you trust the contents of this directory?" }]
   };
-  OPTION_ROW = /^[\u25CF\u25CB\u276F>\u203A]?\s*(\d)\.\s+(.+)$/;
+  OPTION_ROW = /^[\u25CF\u25CB\u276F>\u203A]?\s*(\d)\.\s+(.+)$/;
+  DIALOG_FOOTER = /^[\s\u2502\u2500\u2570\u256F\u256D\u256E\u250C\u2510\u2514\u2518|]*$|enter to (confirm|continue|select)|esc to cancel|use enter to select|press enter|\u2191\/\u2193|arrow keys|tab to|^\(.*\)$/i;
+});
+
+// packages/core/src/diff-view.ts
+function scanStructure(lines) {
+  const meta = new Set;
+  let proven = false;
+  let inHunk = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      proven ||= HUNK_HEADER.test(line);
+      continue;
+    }
+    if (FILE_SECTION_START.test(line)) {
+      inHunk = false;
+      proven ||= line.startsWith("diff --git ");
+      continue;
+    }
+    if (inHunk || !line.startsWith("--- "))
+      continue;
+    if ((lines[i + 1] ?? "").startsWith("+++ ")) {
+      meta.add(i);
+      meta.add(i + 1);
+      i += 1;
+    }
+  }
+  return { meta, proven };
+}
+function countTail(lines) {
+  let added = 0;
+  let removed = 0;
+  for (const line of lines) {
+    if (line.startsWith("+++ ") || line.startsWith("--- "))
+      continue;
+    if (line.startsWith("+"))
+      added += 1;
+    else if (line.startsWith("-"))
+      removed += 1;
+  }
+  return { added, removed };
+}
+function summarizePatch(patch, maxChars = DIFF_MAX_CHARS, maxLines = DIFF_MAX_LINES) {
+  const totalChars = patch.length;
+  if (totalChars === 0)
+    return;
+  const clipped = patch.slice(0, maxChars);
+  const all = clipped.split(`
+`);
+  const cutChars = totalChars > maxChars;
+  const cutLines = all.length > maxLines;
+  const kept = all.slice(0, maxLines);
+  const { meta, proven } = scanStructure(kept);
+  if (!proven)
+    return;
+  let added = 0;
+  let removed = 0;
+  const lines = kept.map((line, i) => {
+    if (meta.has(i) || line.startsWith("@@") || FILE_SECTION_START.test(line)) {
+      return { kind: "meta", text: line };
+    }
+    if (line.startsWith("+")) {
+      added += 1;
+      return { kind: "add", text: line.slice(1) };
+    }
+    if (line.startsWith("-")) {
+      removed += 1;
+      return { kind: "del", text: line.slice(1) };
+    }
+    return { kind: "context", text: line };
+  });
+  if (added + removed === 0)
+    return;
+  const tail = countTail(all.slice(maxLines));
+  added += tail.added;
+  removed += tail.removed;
+  const truncated = cutChars ? "chars" : cutLines ? "lines" : undefined;
+  return {
+    lines: truncated === undefined ? lines : [...lines.slice(0, maxLines - 1), TRUNCATED],
+    added,
+    removed,
+    ...truncated === undefined ? {} : { truncated },
+    totalChars
+  };
+}
+var DIFF_MAX_CHARS = 8000, DIFF_MAX_LINES = 80, TRUNCATED, HUNK_HEADER, FILE_SECTION_START;
+var init_diff_view = __esm(() => {
+  TRUNCATED = { kind: "meta", text: "\u2026 diff truncated \u2026" };
+  HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
+  FILE_SECTION_START = /^(?:diff |index |old mode |new mode |new file mode |deleted file mode |similarity index |dissimilarity index |rename |copy |Binary files )/;
 });
 
 // packages/core/src/doctor.ts
@@ -2824,7 +3262,7 @@ var SEQUENCES, KEY_NAMES;
 var init_keys = __esm(() => {
   SEQUENCES = {
     approve: "\r",
-    deny: "\x1B[B\r",
+    deny: "\x1B",
     enter: "\r",
     esc: "\x1B",
     up: "\x1B[A",
@@ -3300,24 +3738,7 @@ trusted_hash = "${e.hash}"
   }).join(`
 `);
 }
-function codexPermissionDecision(question, answers, denyMessage) {
-  const picked = answers?.find((a) => a.questionIndex === 0)?.selected[0];
-  if (picked === undefined)
-    return;
-  if (picked === question.options[0]?.label) {
-    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
-  }
-  if (picked === question.options[1]?.label) {
-    return {
-      hookSpecificOutput: {
-        hookEventName: "PermissionRequest",
-        decision: { behavior: "deny", ...denyMessage !== undefined ? { message: denyMessage } : {} }
-      }
-    };
-  }
-  return;
-}
-var OBSERVATION_TIMEOUT_SECONDS = 15, CODEX_PERMISSION_TIMEOUT_SECONDS = 120, CODEX_APPROVAL_HOLD_MS = 110000, CODEX_APPROVAL_POST_TIMEOUT_MS = 115000, SESSION_END_TIMEOUT_SECONDS = 2, OBSERVATION_EVENTS, EVENT_KEY_LABELS;
+var OBSERVATION_TIMEOUT_SECONDS = 15, CODEX_PERMISSION_TIMEOUT_SECONDS = 120, CODEX_APPROVAL_POST_TIMEOUT_MS = 115000, SESSION_END_TIMEOUT_SECONDS = 2, OBSERVATION_EVENTS, EVENT_KEY_LABELS;
 var init_codex_hooks = __esm(() => {
   OBSERVATION_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"];
   EVENT_KEY_LABELS = {
@@ -3571,11 +3992,11 @@ var init_prompt_detect = __esm(() => {
 });
 
 // packages/core/src/session-scope.ts
-import path2 from "path";
+import path3 from "path";
 function comparable(target, resolve) {
-  let real = path2.resolve(target);
+  let real = path3.resolve(target);
   try {
-    real = path2.resolve(resolve(real));
+    real = path3.resolve(resolve(real));
   } catch {}
   const trimmed = real.replace(/[\\/]+$/, "");
   return process.platform === "win32" ? trimmed.toLowerCase() : trimmed;
@@ -3583,7 +4004,7 @@ function comparable(target, resolve) {
 function pathWithin(parent, child, resolve = asGiven) {
   const from = comparable(parent, resolve);
   const to = comparable(child, resolve);
-  return to === from || to.startsWith(from + path2.sep);
+  return to === from || to.startsWith(from + path3.sep);
 }
 function sessionInScope(session, scope, resolve = asGiven) {
   if (pathWithin(scope, session.cwd, resolve))
@@ -3614,6 +4035,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,7 +4057,9 @@ var init_src = __esm(() => {
   init_config_paths();
   init_setup_wizard();
   init_agent_registry();
+  init_agent_resume();
   init_self_spawn();
+  init_service();
   init_channel_spi();
   init_update();
   init_errors();
@@ -3645,6 +4071,7 @@ var init_src = __esm(() => {
   init_pty_protocol();
   init_claude_hooks();
   init_onboarding();
+  init_diff_view();
   init_doctor();
   init_stall();
   init_codex_stream();
@@ -3660,19 +4087,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 path6 from "path";
-function writeAtomic(target, contents, mode) {
+import fs7 from "fs";
+import path8 from "path";
+function writeAtomic2(target, contents, mode) {
   const tmp = `${target}.tmp`;
-  fs5.writeFileSync(tmp, contents, { mode });
-  fs5.renameSync(tmp, target);
+  fs7.writeFileSync(tmp, contents, { mode });
+  fs7.renameSync(tmp, target);
   if (process.platform !== "win32")
-    fs5.chmodSync(target, mode);
+    fs7.chmodSync(target, mode);
 }
 
 class ConfigStore {
@@ -3688,16 +4116,16 @@ class ConfigStore {
   }
   load() {
     this.loadError = undefined;
-    fs5.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
+    fs7.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
     if (process.platform !== "win32") {
       try {
-        fs5.chmodSync(this.paths.configDir, DIR_MODE);
+        fs7.chmodSync(this.paths.configDir, DIR_MODE);
       } catch {}
     }
     this.config = structuredClone(DEFAULT_CONFIG);
-    if (fs5.existsSync(this.paths.configFile)) {
+    if (fs7.existsSync(this.paths.configFile)) {
       try {
-        const parsed = parseConfig(JSON.parse(fs5.readFileSync(this.paths.configFile, "utf8")));
+        const parsed = parseConfig(JSON.parse(fs7.readFileSync(this.paths.configFile, "utf8")));
         if ("errors" in parsed)
           this.loadError = parsed.errors.join("; ");
         else
@@ -3707,10 +4135,10 @@ class ConfigStore {
       }
     }
     this.secrets = {};
-    if (fs5.existsSync(this.paths.secretsFile)) {
+    if (fs7.existsSync(this.paths.secretsFile)) {
       this.tightenPermissions(this.paths.secretsFile);
       try {
-        const raw = JSON.parse(fs5.readFileSync(this.paths.secretsFile, "utf8"));
+        const raw = JSON.parse(fs7.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 +4154,8 @@ class ConfigStore {
     if (process.platform === "win32")
       return;
     try {
-      if ((fs5.statSync(file).mode & 63) !== 0)
-        fs5.chmodSync(file, FILE_MODE);
+      if ((fs7.statSync(file).mode & 63) !== 0)
+        fs7.chmodSync(file, FILE_MODE);
     } catch {}
   }
   get() {
@@ -3735,7 +4163,7 @@ class ConfigStore {
   }
   health() {
     return configHealth({
-      fileExists: fs5.existsSync(this.paths.configFile),
+      fileExists: fs7.existsSync(this.paths.configFile),
       parseError: this.loadError,
       config: this.resolved()
     });
@@ -3768,7 +4196,7 @@ class ConfigStore {
     const parsed = parseConfig(candidate);
     if ("errors" in parsed)
       throw new Error(parsed.errors.join("; "));
-    writeAtomic(this.paths.configFile, `${JSON.stringify(parsed.config, null, 2)}
+    writeAtomic2(this.paths.configFile, `${JSON.stringify(parsed.config, null, 2)}
 `, FILE_MODE);
     this.config = parsed.config;
     this.loadError = undefined;
@@ -3780,11 +4208,11 @@ class ConfigStore {
       delete this.secrets[dottedPath];
     else
       this.secrets[dottedPath] = value;
-    if (!fs5.existsSync(this.paths.configFile)) {
-      writeAtomic(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
+    if (!fs7.existsSync(this.paths.configFile)) {
+      writeAtomic2(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
 `, FILE_MODE);
     }
-    writeAtomic(this.paths.secretsFile, `${JSON.stringify(this.secrets, null, 2)}
+    writeAtomic2(this.paths.secretsFile, `${JSON.stringify(this.secrets, null, 2)}
 `, FILE_MODE);
   }
   hasSecret(dottedPath) {
@@ -3810,7 +4238,7 @@ class ConfigStore {
   fingerprint() {
     const stamp = (file) => {
       try {
-        return String(fs5.statSync(file).mtimeMs);
+        return String(fs7.statSync(file).mtimeMs);
       } catch {
         return "-";
       }
@@ -3832,8 +4260,8 @@ function applyPath(config, dottedPath, value) {
 function defaultConfigStorePaths(configDir) {
   return {
     configDir,
-    configFile: path6.join(configDir, "config.json"),
-    secretsFile: path6.join(configDir, "secrets.json")
+    configFile: path8.join(configDir, "config.json"),
+    secretsFile: path8.join(configDir, "secrets.json")
   };
 }
 var ENV_ALIASES, DIR_MODE = 448, FILE_MODE = 384;
@@ -3852,13 +4280,13 @@ var init_config_store = __esm(() => {
 });
 
 // packages/daemon/src/shell.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 function findExecutable(name, env) {
   const isWindows = env.platform === "win32";
-  const join = isWindows ? path7.win32.join : path7.posix.join;
+  const join = isWindows ? path9.win32.join : path9.posix.join;
   const separator = isWindows ? ";" : ":";
-  const extensions = isWindows ? path7.win32.extname(name).length > 0 ? [""] : env.pathExt.split(";").filter((e) => e.length > 0) : [""];
+  const extensions = isWindows ? path9.win32.extname(name).length > 0 ? [""] : env.pathExt.split(";").filter((e) => e.length > 0) : [""];
   for (const rawDir of env.pathEnv.split(separator)) {
     const dir = rawDir.trim().replace(/^"|"$/g, "");
     if (dir.length === 0)
@@ -3876,16 +4304,16 @@ 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) => fs8.existsSync(candidate)
   });
 }
 function resolveShell(kind) {
   if (process.platform !== "win32")
     return resolvePosixShell(kind);
   const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
-  const windowsPowershell = path7.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const windowsPowershell = path9.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
   if (kind === "cmd") {
-    return { kind: "cmd", exe: path7.join(systemRoot, "System32", "cmd.exe") };
+    return { kind: "cmd", exe: path9.join(systemRoot, "System32", "cmd.exe") };
   }
   if (kind === "powershell") {
     return { kind: "powershell", exe: windowsPowershell };
@@ -3913,7 +4341,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) => fs8.existsSync(c.exe));
   if (found)
     return found;
   return { kind: "sh", exe: "/bin/sh" };
@@ -3958,24 +4386,24 @@ function ipcEndpoint(platform, user, env) {
     const suffix = `-${shortHash(env.runtimeDir)}`;
     return `\\\\.\\pipe\\axterm-${safeUser}${suffix}`;
   }
-  return path7.posix.join(env.runtimeDir, "axterm.sock");
+  return path9.posix.join(env.runtimeDir, "axterm.sock");
 }
 var cachedPwsh;
 var init_shell = () => {};
 
 // packages/daemon/src/paths.ts
-import fs7 from "fs";
-import os3 from "os";
-import path8 from "path";
+import fs9 from "fs";
+import os4 from "os";
+import path10 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 });
+    fs9.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);
+      fs9.chmodSync(dir, DIR_MODE2);
     } catch {}
   }
 }
@@ -3983,14 +4411,14 @@ function restrictFile(file) {
   if (process.platform === "win32")
     return;
   try {
-    fs7.chmodSync(file, 384);
+    fs9.chmodSync(file, 384);
   } catch {}
 }
 function log(message) {
   const line = `${new Date().toISOString()} ${message}
 `;
   try {
-    fs7.appendFileSync(LOG_FILE, line);
+    fs9.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;
@@ -4007,15 +4435,15 @@ var init_paths = __esm(() => {
   DB_PATH = PATHS.dbFile;
   RUNTIME_FILE2 = PATHS.runtimeFile;
   HOOK_ENDPOINT_FILE = PATHS.hookEndpointFile;
-  PIPE_PATH = ipcEndpoint(process.platform, os3.userInfo().username, {
+  PIPE_PATH = ipcEndpoint(process.platform, os4.userInfo().username, {
     runtimeDir: PATHS.runtimeDir
   });
-  LOG_FILE = path8.join(LOG_DIR, "daemon.log");
+  LOG_FILE = path10.join(LOG_DIR, "daemon.log");
 });
 
 // packages/daemon/src/store.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 import { Database } from "bun:sqlite";
 function rowToInfo(row) {
   return {
@@ -4046,7 +4474,7 @@ function rowToInfo(row) {
 class Store {
   db;
   constructor(dbPath = DB_PATH) {
-    fs8.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    fs10.mkdirSync(path11.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath, { strict: true });
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`
@@ -4125,8 +4553,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 +4642,11 @@ var init_store = __esm(() => {
 });
 
 // packages/daemon/src/config-migrate.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import { Database as Database2 } from "bun:sqlite";
 function checkpointWal(dbFile) {
-  if (!fs9.existsSync(dbFile))
+  if (!fs11.existsSync(dbFile))
     return;
   try {
     const db = new Database2(dbFile);
@@ -4226,32 +4656,32 @@ function checkpointWal(dbFile) {
 }
 function relocate(source, target) {
   try {
-    fs9.renameSync(source, target);
+    fs11.renameSync(source, target);
   } catch {
-    fs9.cpSync(source, target, { recursive: true });
+    fs11.cpSync(source, target, { recursive: true });
   }
 }
 function moveInto(from, to, notes) {
-  checkpointWal(path10.join(from, "axterm.db"));
-  fs9.mkdirSync(to, { recursive: true });
+  checkpointWal(path12.join(from, "axterm.db"));
+  fs11.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))
+    const source = path12.join(from, entry);
+    const target = path12.join(to, entry);
+    if (!fs11.existsSync(source))
       continue;
-    if (!fs9.existsSync(target)) {
+    if (!fs11.existsSync(target)) {
       relocate(source, target);
       notes.push(`moved ${entry}`);
       continue;
     }
-    if (!fs9.statSync(source).isDirectory() || !fs9.statSync(target).isDirectory())
+    if (!fs11.statSync(source).isDirectory() || !fs11.statSync(target).isDirectory())
       continue;
     let moved = 0;
-    for (const child of fs9.readdirSync(source)) {
-      const childTarget = path10.join(target, child);
-      if (fs9.existsSync(childTarget))
+    for (const child of fs11.readdirSync(source)) {
+      const childTarget = path12.join(target, child);
+      if (fs11.existsSync(childTarget))
         continue;
-      relocate(path10.join(source, child), childTarget);
+      relocate(path12.join(source, child), childTarget);
       moved += 1;
     }
     if (moved > 0)
@@ -4261,29 +4691,29 @@ function moveInto(from, to, notes) {
 function migrateLegacyConfig(input) {
   const notes = [];
   const storePaths = defaultConfigStorePaths(input.configDir);
-  if (fs9.existsSync(storePaths.configFile))
+  if (fs11.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) => fs11.existsSync(path12.join(dir, "config.json")));
   if (configSource !== undefined) {
-    fs9.mkdirSync(input.configDir, { recursive: true });
-    fs9.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
-    const secrets = path10.join(configSource, "secrets.json");
-    if (fs9.existsSync(secrets)) {
-      fs9.copyFileSync(secrets, storePaths.secretsFile);
+    fs11.mkdirSync(input.configDir, { recursive: true });
+    fs11.copyFileSync(path12.join(configSource, "config.json"), storePaths.configFile);
+    const secrets = path12.join(configSource, "secrets.json");
+    if (fs11.existsSync(secrets)) {
+      fs11.copyFileSync(secrets, storePaths.secretsFile);
       try {
-        fs9.chmodSync(storePaths.secretsFile, 384);
+        fs11.chmodSync(storePaths.secretsFile, 384);
       } catch {}
     }
-    fs9.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
+    fs11.writeFileSync(path12.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) => fs11.existsSync(path12.join(dir, "axterm.db")));
   if (legacy !== undefined) {
     moveInto(legacy, input.stateDir, notes);
-    fs9.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
+    fs11.writeFileSync(path12.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
   ${input.stateDir}
 and configuration in:
   ${input.configDir}
@@ -4292,8 +4722,8 @@ 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))
+  const dbFile = path12.join(input.stateDir, "axterm.db");
+  if (!fs11.existsSync(dbFile))
     return { migrated: notes.length > 0, ...legacy ? { from: legacy } : {}, notes };
   const store = new Store(dbFile);
   const machine2 = store.getConfig("axterm_machine");
@@ -5131,13 +5561,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 path11 from "path";
+import fs12 from "fs";
+import path13 from "path";
 function installExtensionAsset(targetDir) {
-  fs10.mkdirSync(targetDir, { recursive: true });
-  const target = path11.join(targetDir, "axterm-agent-status.mjs");
+  fs12.mkdirSync(targetDir, { recursive: true });
+  const target = path13.join(targetDir, "axterm-agent-status.mjs");
   const js = new Bun.Transpiler({ loader: "ts" }).transformSync(extensionSource);
-  fs10.writeFileSync(target, MANAGED_HEADER + js);
+  fs12.writeFileSync(target, MANAGED_HEADER + js);
   return target;
 }
 var extensionSource, MANAGED_HEADER = `// @axterm-managed-omp-extension
@@ -5150,8 +5580,8 @@ var init_ext_install = __esm(() => {
 
 // packages/daemon/src/workspace-local.ts
 import { spawn as spawn2 } from "child_process";
-import fs11 from "fs/promises";
-import path12 from "path";
+import fs13 from "fs/promises";
+import path14 from "path";
 function isAbsent(error) {
   const code = error?.code;
   return code === "ENOENT" || code === "ENOTDIR";
@@ -5164,10 +5594,10 @@ class LocalWorkspace {
     this.stagingDir = stagingDir;
   }
   async list(dir) {
-    const dirents = await fs11.readdir(dir, { withFileTypes: true });
+    const dirents = await fs13.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 fs13.lstat(path14.join(dir, dirent.name));
       } catch (error) {
         if (isAbsent(error))
           return;
@@ -5191,7 +5621,7 @@ class LocalWorkspace {
   }
   async stat(target) {
     try {
-      const stat = await fs11.stat(target);
+      const stat = await fs13.stat(target);
       const kind = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
       return { kind, size: stat.size, mtimeMs: stat.mtimeMs };
     } catch (error) {
@@ -5202,8 +5632,8 @@ class LocalWorkspace {
   }
   async read(file, limit) {
     if (limit === undefined)
-      return await fs11.readFile(file);
-    const handle = await fs11.open(file, "r");
+      return await fs13.readFile(file);
+    const handle = await fs13.open(file, "r");
     try {
       const buffer = Buffer.allocUnsafe(Math.min(limit, (await handle.stat()).size));
       let filled = 0;
@@ -5222,10 +5652,10 @@ class LocalWorkspace {
     return Promise.resolve(file);
   }
   async mkdirp(dir, mode) {
-    await fs11.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
+    await fs13.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
   }
   async write(file, bytes, mode) {
-    await fs11.writeFile(file, bytes, mode === undefined ? undefined : { mode });
+    await fs13.writeFile(file, bytes, mode === undefined ? undefined : { mode });
   }
   exec(argv, cwd) {
     const [command, ...args] = argv;
@@ -5254,9 +5684,9 @@ var init_workspace_local = () => {};
 
 // packages/daemon/src/hook-host.ts
 import { randomBytes } from "crypto";
-import fs12 from "fs";
+import fs14 from "fs";
 import http from "http";
-import path13 from "path";
+import path15 from "path";
 function header(req, name) {
   const value = req.headers[name];
   return Array.isArray(value) ? value[0] : value;
@@ -5270,17 +5700,18 @@ class HookHost {
   }
   sessions = new Map;
   pendingAsks = new Map;
+  refusedHooks = new Set;
   endpointFile;
   server;
   askOpenHandler;
   resolveWorkspace;
   local;
-  codexApprovalHoldMs;
-  codexAskSeq = 0;
+  approvalHoldMs;
+  approvalSeq = 0;
   constructor(options) {
     this.endpointFile = options.endpointFile;
-    this.codexApprovalHoldMs = options.codexApprovalHoldMs ?? CODEX_APPROVAL_HOLD_MS;
-    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path13.join(RUNTIME_DIR, "materialised")));
+    this.approvalHoldMs = options.approvalHoldMs ?? APPROVAL_HOLD_MS;
+    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path15.join(RUNTIME_DIR, "materialised")));
   }
   start() {
     const server = http.createServer((req, res) => this.handle(req, res));
@@ -5296,16 +5727,19 @@ class HookHost {
     return promise;
   }
   writeEndpointFile(port) {
-    fs12.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
+    fs14.mkdirSync(path15.dirname(this.endpointFile), { recursive: true });
     const tmp = `${this.endpointFile}.tmp`;
-    fs12.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
+    fs14.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
 AXTERM_HOOK_TOKEN=${this.token}
 `);
-    fs12.renameSync(tmp, this.endpointFile);
+    fs14.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) {
@@ -5367,11 +5801,11 @@ AXTERM_HOOK_TOKEN=${this.token}
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf8");
       if (isClaude) {
-        this.handleAgentHook(req, raw, res, mapClaudeHook, "claude");
+        this.handleDecidingAgentHook(req, raw, res, "claude");
         return;
       }
       if (isCodex) {
-        this.handleCodex(req, raw, res);
+        this.handleDecidingAgentHook(req, raw, res, "codex");
         return;
       }
       if (isGemini) {
@@ -5394,7 +5828,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,9 +5863,11 @@ 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) {
+  handleDecidingAgentHook(req, raw, res, agent) {
     const auth = this.agentHookSession(req);
     if (!auth) {
       res.writeHead(200).end();
@@ -5444,20 +5880,27 @@ AXTERM_HOOK_TOKEN=${this.token}
       res.writeHead(200).end();
       return;
     }
+    const dispatch = () => {
+      const events = withConversationId(mapClaudeHook(input), {
+        sessionId: input.session_id,
+        subagentId: input.agent_id
+      });
+      this.dispatchHookPayloads(auth.session, events, agent);
+    };
     if (input.hook_event_name !== "PermissionRequest") {
       res.writeHead(200).end();
-      this.dispatchHookPayloads(auth.session, mapClaudeHook(input), "codex");
+      dispatch();
       return;
     }
     const question = buildApprovalQuestion(input.tool_name);
-    this.dispatchHookPayloads(auth.session, mapClaudeHook(input), "codex");
-    const askId = `codex-${auth.sessionId}-${this.codexAskSeq++}`;
+    dispatch();
+    const askId = `${agent}-${auth.sessionId}-${this.approvalSeq++}`;
     let fence;
     const settle = (body) => {
       clearTimeout(fence);
       if (res.writableEnded)
         return;
-      const decision = body.status === "answered" ? codexPermissionDecision(question, body.answers, t("codex.approval.denied")) : undefined;
+      const decision = body.status === "answered" ? hookPermissionDecision(question, body.answers, t("agent.approval.denied")) : undefined;
       if (decision === undefined) {
         res.writeHead(200).end();
         return;
@@ -5478,15 +5921,22 @@ AXTERM_HOOK_TOKEN=${this.token}
         return;
       this.pendingAsks.delete(askId);
       settle({ status: "cancelled" });
-    }, this.codexApprovalHoldMs);
+    }, this.approvalHoldMs);
     fence.unref?.();
   }
   agentHookSession(req) {
     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) {
@@ -5575,8 +6025,112 @@ var init_hook_host = __esm(() => {
   MAX_BODY_BYTES = 256 * 1024;
 });
 
+// packages/daemon/src/process-guards.ts
+class RejectionLogLimiter {
+  detailLimit;
+  windowMs;
+  windowStartedAt;
+  details = 0;
+  noticeEmitted = false;
+  constructor(detailLimit = DEFAULT_REJECTION_DETAILS, windowMs = DEFAULT_REJECTION_WINDOW_MS) {
+    this.detailLimit = detailLimit;
+    this.windowMs = windowMs;
+    if (!Number.isInteger(detailLimit) || detailLimit < 1)
+      throw new RangeError("detailLimit must be a positive integer");
+    if (!Number.isFinite(windowMs) || windowMs <= 0)
+      throw new RangeError("windowMs must be positive");
+  }
+  decide(now) {
+    if (this.windowStartedAt === undefined || now - this.windowStartedAt >= this.windowMs || now < this.windowStartedAt) {
+      this.windowStartedAt = now;
+      this.details = 0;
+      this.noticeEmitted = false;
+    }
+    if (this.details < this.detailLimit) {
+      this.details++;
+      return "detail";
+    }
+    if (!this.noticeEmitted) {
+      this.noticeEmitted = true;
+      return "notice";
+    }
+    return "drop";
+  }
+}
+function thrownText(reason) {
+  let text;
+  if (reason instanceof Error) {
+    text = reason.stack ?? reason.message;
+  } else if (typeof reason === "string") {
+    text = reason;
+  } else {
+    try {
+      text = JSON.stringify(reason) ?? String(reason);
+    } catch {
+      text = String(reason);
+    }
+  }
+  if (text.length <= MAX_BREADCRUMB_CHARS)
+    return text;
+  return `${text.slice(0, MAX_BREADCRUMB_CHARS)}\u2026 [truncated]`;
+}
+
+class ProcessCrashGuards {
+  options;
+  limiter;
+  now;
+  fatal = false;
+  uninstallCurrent;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.limiter = new RejectionLogLimiter(options.rejectionDetailsPerWindow, options.rejectionWindowMs);
+  }
+  install(events) {
+    if (this.uninstallCurrent !== undefined)
+      throw new Error("process crash guards are already installed");
+    const uncaught = (reason) => this.fatalExit("uncaughtException", reason);
+    const rejected = (reason) => this.unhandledRejection(reason);
+    events.on("uncaughtException", uncaught);
+    events.on("unhandledRejection", rejected);
+    let installed = true;
+    const uninstall = () => {
+      if (!installed)
+        return;
+      installed = false;
+      events.off("uncaughtException", uncaught);
+      events.off("unhandledRejection", rejected);
+      if (this.uninstallCurrent === uninstall)
+        this.uninstallCurrent = undefined;
+    };
+    this.uninstallCurrent = uninstall;
+    return uninstall;
+  }
+  startupFailed(reason) {
+    this.fatalExit("startupFailure", reason);
+  }
+  unhandledRejection(reason) {
+    if (this.fatal)
+      return;
+    const decision = this.limiter.decide(this.now());
+    if (decision === "detail") {
+      this.options.log(`unhandledRejection: ${thrownText(reason)}`);
+    } else if (decision === "notice") {
+      this.options.log("unhandledRejection: suppressing further unhandled rejections in this rate-limit window");
+    }
+  }
+  fatalExit(origin, reason) {
+    if (this.fatal)
+      return;
+    this.fatal = true;
+    this.options.log(`${origin}: ${thrownText(reason)}`);
+    this.options.exit(1);
+  }
+}
+var DEFAULT_REJECTION_DETAILS = 20, DEFAULT_REJECTION_WINDOW_MS = 60000, MAX_BREADCRUMB_CHARS = 16384;
+
 // packages/daemon/src/rpc-server.ts
-import fs13 from "fs";
+import fs15 from "fs";
 import net2 from "net";
 function writeFrame(socket, frame) {
   if (!socket.destroyed)
@@ -5686,6 +6240,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 +6368,7 @@ function startRpcServer(options) {
   });
   if (process.platform !== "win32") {
     try {
-      fs13.unlinkSync(pipePath);
+      fs15.unlinkSync(pipePath);
     } catch {}
   }
   server.listen(pipePath, () => {
@@ -5827,17 +6383,34 @@ var init_rpc_server = __esm(() => {
 });
 
 // packages/daemon/src/codex-home.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path16 from "path";
 function codexTrustKeyPath(home) {
   const resolved = (() => {
     try {
-      return fs14.realpathSync.native(home);
+      return fs16.realpathSync.native(home);
     } catch {
-      return path14.resolve(home);
+      return path16.resolve(home);
     }
   })();
-  return path14.join(resolved, "hooks.json");
+  return path16.join(resolved, "hooks.json");
+}
+function referenceCredential(source, target, ops) {
+  const symlink = ops?.symlink ?? ((s, t2) => fs16.symlinkSync(s, t2, "file"));
+  const link = ops?.link ?? fs16.linkSync;
+  try {
+    symlink(source, target);
+    return "symlink";
+  } catch {
+    try {
+      link(source, target);
+      return "hardlink";
+    } catch {
+      fs16.copyFileSync(source, target);
+      fs16.chmodSync(target, 384);
+      return "copy";
+    }
+  }
 }
 var init_codex_home = () => {};
 
@@ -5853,15 +6426,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,8 +6494,8 @@ function slugifyBranch(branch) {
 var MAX_SLUG_LENGTH = 60;
 
 // packages/daemon/src/git.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path17 from "path";
 async function git(ws, cwd, args) {
   const run = await ws.exec(["git", ...args], cwd);
   return {
@@ -5918,15 +6512,15 @@ async function gitOrThrow(ws, cwd, args) {
   return result.stdout;
 }
 function canonicalPath(target) {
-  let resolved = path15.resolve(target);
+  let resolved = path17.resolve(target);
   try {
-    resolved = fs15.realpathSync.native(resolved);
+    resolved = fs17.realpathSync.native(resolved);
   } catch {}
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 async function resolveRepoRoot(ws, cwd) {
   const result = await git(ws, cwd, ["rev-parse", "--show-toplevel"]);
-  return result.ok ? path15.resolve(result.stdout) : undefined;
+  return result.ok ? path17.resolve(result.stdout) : undefined;
 }
 async function currentBranch(ws, cwd) {
   const result = await git(ws, cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -5935,8 +6529,8 @@ async function currentBranch(ws, cwd) {
 async function listWorktrees(ws, repoRoot) {
   return parseWorktreeList(await gitOrThrow(ws, repoRoot, ["worktree", "list", "--porcelain"]));
 }
-function worktreePathFor(repoRoot, branch, root = path15.join(STATE_DIR, "worktrees")) {
-  return path15.join(root, slugifyBranch(path15.basename(repoRoot)), slugifyBranch(branch));
+function worktreePathFor(repoRoot, branch, root = path17.join(STATE_DIR, "worktrees")) {
+  return path17.join(root, slugifyBranch(path17.basename(repoRoot)), slugifyBranch(branch));
 }
 async function createWorktree(ws, options) {
   const { repoRoot, branch, base } = options;
@@ -5944,7 +6538,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 });
+  fs17.mkdirSync(path17.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);
@@ -6005,7 +6599,7 @@ async function diffStat(ws, worktreePath, base) {
   const untracked = await untrackedFiles(ws, worktreePath);
   let newLines = 0;
   for (const file of untracked)
-    newLines += await countLines(ws, path15.join(worktreePath, file));
+    newLines += await countLines(ws, path17.join(worktreePath, file));
   return {
     filesChanged: a.filesChanged + b.filesChanged + untracked.length,
     insertions: a.insertions + b.insertions + newLines,
@@ -6028,21 +6622,84 @@ async function changedFiles(ws, worktreePath, base, limit = 20) {
     names.add(file);
   return [...names].slice(0, limit);
 }
-var UNTRACKED_LINE_SCAN_LIMIT;
+async function diffPatch(ws, worktreePath, base, maxChars = 64 * 1024) {
+  const parts = [];
+  let size = 0;
+  const push = (text) => {
+    if (size >= maxChars)
+      return false;
+    const room = maxChars - size;
+    const piece = text.length > room ? text.slice(0, room) : text;
+    parts.push(piece);
+    size += piece.length;
+    return piece.length === text.length;
+  };
+  for (const args of [
+    ["diff", `${base}...HEAD`, "--", "."],
+    ["diff", "HEAD"]
+  ]) {
+    const out = await git(ws, worktreePath, args);
+    if (out.ok && out.stdout.trim().length > 0 && !push(`${out.stdout.replace(/\s+$/, "")}
+`)) {
+      return parts.join("");
+    }
+  }
+  for (const file of await untrackedFiles(ws, worktreePath)) {
+    if (size >= maxChars)
+      break;
+    let text;
+    try {
+      const stat = await ws.stat(path17.join(worktreePath, file));
+      if (stat?.kind !== "file" || stat.size > UNTRACKED_LINE_SCAN_LIMIT)
+        continue;
+      text = new TextDecoder().decode(await ws.read(path17.join(worktreePath, file)));
+    } catch {
+      continue;
+    }
+    if (text.slice(0, 8000).includes("\x00")) {
+      if (!push(`diff --git a/${file} b/${file}
+Binary files /dev/null and b/${file} differ
+`))
+        break;
+      continue;
+    }
+    const lines = text.split(`
+`);
+    if (lines.at(-1) === "")
+      lines.pop();
+    const shown = lines.slice(0, UNTRACKED_PATCH_LINES);
+    const body = shown.map((line) => `+${line}`).join(`
+`);
+    const elided = lines.length > shown.length ? `
++\u2026 ${lines.length - shown.length} more lines
+` : `
+`;
+    const header2 = `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1,${lines.length} @@
+`;
+    if (!push(`${header2}${body}${elided}`))
+      break;
+  }
+  return parts.join("");
+}
+var UNTRACKED_LINE_SCAN_LIMIT, UNTRACKED_PATCH_LINES = 40;
 var init_git = __esm(() => {
   init_paths();
   UNTRACKED_LINE_SCAN_LIMIT = 1024 * 1024;
 });
 
 // packages/daemon/src/claude-store.ts
-import fs16 from "fs";
-import os4 from "os";
-import path16 from "path";
+import fs18 from "fs";
+import os5 from "os";
+import path18 from "path";
 function claudeConfigDir(env = process.env) {
   const override = env["CLAUDE_CONFIG_DIR"];
   if (override !== undefined && override.length > 0)
     return override;
-  return path16.join(os4.homedir(), ".claude");
+  return path18.join(os5.homedir(), ".claude");
 }
 function resumedConversationId(argv) {
   for (let i = 0;i < argv.length; i++) {
@@ -6058,29 +6715,65 @@ function resumedConversationId(argv) {
   return;
 }
 function claudeConversationExists(configDir, conversationId) {
-  const projects = path16.join(configDir, "projects");
+  const projects = path18.join(configDir, "projects");
   let entries;
   try {
-    entries = fs16.readdirSync(projects);
+    entries = fs18.readdirSync(projects);
   } catch {
     return;
   }
   const file = `${conversationId}.jsonl`;
   for (const entry of entries) {
     try {
-      if (fs16.existsSync(path16.join(projects, entry, file)))
+      if (fs18.existsSync(path18.join(projects, entry, file)))
         return true;
     } catch {}
   }
   return false;
 }
+function claudeConversationCwd(configDir, conversationId) {
+  const projects = path18.join(configDir, "projects");
+  let entries;
+  try {
+    entries = fs18.readdirSync(projects);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const file = path18.join(projects, entry, `${conversationId}.jsonl`);
+    let head;
+    try {
+      const handle = fs18.openSync(file, "r");
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        const read = fs18.readSync(handle, buffer, 0, buffer.byteLength, 0);
+        head = buffer.subarray(0, read).toString("utf8");
+      } finally {
+        fs18.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;
 });
 
 // packages/daemon/src/injector.ts
-import { setTimeout as delay2 } from "timers/promises";
+import { setTimeout as delay3 } from "timers/promises";
 
 class Injector {
   queues = new Map;
@@ -6095,14 +6788,14 @@ class Injector {
       try {
         const deadline = Date.now() + 5000;
         while (!session.pasteReady && !session.isExited && Date.now() < deadline) {
-          await delay2(100);
+          await delay3(100);
         }
         session.write(CTRL_U);
-        await delay2(CLEAR_SETTLE_MS);
+        await delay3(CLEAR_SETTLE_MS);
         for (const chunk of iteratePasteChunks(text)) {
           session.write(chunk);
         }
-        await delay2(SUBMIT_DELAY_MS);
+        await delay3(SUBMIT_DELAY_MS);
         session.write(SUBMIT);
       } catch (err) {
         session.write(BRACKETED_PASTE_END);
@@ -6114,7 +6807,7 @@ class Injector {
   interrupt(session) {
     return this.enqueue(session.info.id, async () => {
       session.write(ESC);
-      await delay2(500);
+      await delay3(500);
     });
   }
 }
@@ -6194,6 +6887,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 +6901,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 +6970,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 +6994,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 +7017,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 os5 from "os";
-import path17 from "path";
+import fs19 from "fs";
+import os6 from "os";
+import path19 from "path";
 function hostFile(runtimeDir) {
-  return path17.join(runtimeDir, "pty-host.json");
+  return path19.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(fs19.readFileSync(file, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return;
     const { pid, endpoint, token, version: version2 } = parsed;
@@ -6332,8 +7048,8 @@ function isRunning(pid) {
   }
 }
 function hostEndpoint(runtimeDir) {
-  const base = ipcEndpoint(process.platform, os5.userInfo().username, { runtimeDir });
-  return process.platform === "win32" ? `${base}-pty` : path17.join(runtimeDir, "axterm-pty.sock");
+  const base = ipcEndpoint(process.platform, os6.userInfo().username, { runtimeDir });
+  return process.platform === "win32" ? `${base}-pty` : path19.join(runtimeDir, "axterm-pty.sock");
 }
 async function ensurePtyHost(location) {
   const file = hostFile(location.runtimeDir);
@@ -6344,7 +7060,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 });
+    fs19.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,10 +7089,41 @@ 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)}
-`, { mode: 384 });
-  restrictFile(file);
+  const dir = path19.dirname(file);
+  const tmp = `${file}.tmp`;
+  fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+  let handle;
+  try {
+    handle = fs19.openSync(tmp, "w", 384);
+    fs19.writeFileSync(handle, `${JSON.stringify(info, null, 2)}
+`, "utf8");
+    fs19.fsyncSync(handle);
+    fs19.closeSync(handle);
+    handle = undefined;
+    restrictFile(tmp);
+    fs19.renameSync(tmp, file);
+    restrictFile(file);
+    if (process.platform !== "win32") {
+      try {
+        const directory = fs19.openSync(dir, "r");
+        try {
+          fs19.fsyncSync(directory);
+        } finally {
+          fs19.closeSync(directory);
+        }
+      } catch {}
+    }
+  } catch (err) {
+    if (handle !== undefined) {
+      try {
+        fs19.closeSync(handle);
+      } catch {}
+    }
+    try {
+      fs19.rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
 }
 var init_pty_host_launch = __esm(() => {
   init_src();
@@ -6385,8 +7132,8 @@ var init_pty_host_launch = __esm(() => {
 });
 
 // packages/daemon/src/pty.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import path18 from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import path20 from "path";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 
 class Fanout {
@@ -6407,13 +7154,13 @@ class Fanout {
 }
 function killTree(pid, exeName) {
   if (process.platform === "win32") {
-    const check = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
+    const check = spawnSync3("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
       encoding: "utf8",
       windowsHide: true
     });
     const image = check.stdout?.split(",")[0]?.replace(/"/g, "").toLowerCase() ?? "";
     if (image === exeName) {
-      spawnSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
+      spawnSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
     }
     return;
   }
@@ -6486,7 +7233,7 @@ function spawnPty(options) {
       }
     }
   });
-  handle = new BunPtyHandle(proc, path18.basename(options.exe).toLowerCase());
+  handle = new BunPtyHandle(proc, path20.basename(options.exe).toLowerCase());
   proc.exited.then((code) => handle?.finish(code ?? null));
   return handle;
 }
@@ -6494,7 +7241,7 @@ var init_pty = () => {};
 
 // packages/daemon/src/occupancy.ts
 import { spawn as spawn4 } from "child_process";
-import fs18 from "fs/promises";
+import fs20 from "fs/promises";
 function shellOccupied(shellPid) {
   return process.platform === "win32" ? occupiedFromSnapshot(shellPid) : occupiedFromPidProbe(shellPid);
 }
@@ -6539,11 +7286,11 @@ async function occupiedFromSnapshot(shellPid) {
 }
 async function childrenViaProc(pid) {
   try {
-    const children = await fs18.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    const children = await fs20.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
     return children.trim().length > 0;
   } catch {
     try {
-      await fs18.access(`/proc/${pid}`);
+      await fs20.access(`/proc/${pid}`);
       return;
     } catch {
       return false;
@@ -6607,20 +7354,20 @@ var init_occupancy = __esm(() => {
 });
 
 // packages/daemon/src/agent-store.ts
-import fs19 from "fs";
-import os6 from "os";
-import path19 from "path";
+import fs21 from "fs";
+import os7 from "os";
+import path21 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 = fs21.openSync(file, "r");
+    const size = fs21.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);
+    fs21.readSync(fd, buffer, 0, length, size - length);
     const text = buffer.toString("utf8");
     const lines = text.split(`
 `);
@@ -6633,46 +7380,46 @@ function readTailLines(file, maxBytes) {
     return [];
   } finally {
     if (fd !== undefined)
-      fs19.closeSync(fd);
+      fs21.closeSync(fd);
   }
 }
 function claudeConfigDir2() {
-  return process.env["CLAUDE_CONFIG_DIR"] ?? path19.join(os6.homedir(), ".claude");
+  return process.env["CLAUDE_CONFIG_DIR"] ?? path21.join(os7.homedir(), ".claude");
 }
 function codexHome() {
-  return path19.join(STATE_DIR, "codex-home");
+  return path21.join(STATE_DIR, "codex-home");
 }
 function ompAgentDb() {
-  return path19.join(os6.homedir(), ".omp", "agent", "agent.db");
+  return path21.join(os7.homedir(), ".omp", "agent", "agent.db");
 }
 function findCodexRollout(sessionId) {
-  const root = path19.join(codexHome(), "sessions");
+  const root = path21.join(codexHome(), "sessions");
   for (const shard2 of codexRolloutShards(sessionId)) {
-    const dir = path19.join(root, ...shard2.split("/"));
+    const dir = path21.join(root, ...shard2.split("/"));
     let entries;
     try {
-      entries = fs19.readdirSync(dir);
+      entries = fs21.readdirSync(dir);
     } catch {
       continue;
     }
     const match2 = entries.find((name) => name.endsWith(`-${sessionId}.jsonl`));
     if (match2 !== undefined)
-      return path19.join(dir, match2);
+      return path21.join(dir, match2);
   }
   return;
 }
 function newestCodexRollout() {
-  const root = path19.join(codexHome(), "sessions");
+  const root = path21.join(codexHome(), "sessions");
   let best;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs19.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path19.join(dir, entry.name);
+      const full = path21.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (depth < 3)
           walk(full, depth + 1);
@@ -6681,7 +7428,7 @@ function newestCodexRollout() {
       if (!entry.name.endsWith(".jsonl"))
         continue;
       try {
-        const { mtimeMs } = fs19.statSync(full);
+        const { mtimeMs } = fs21.statSync(full);
         if (!best || mtimeMs > best.mtimeMs)
           best = { file: full, mtimeMs };
       } catch {}
@@ -6692,7 +7439,7 @@ function newestCodexRollout() {
 }
 function ompQuotaFacts() {
   const file = ompAgentDb();
-  if (!fs19.existsSync(file))
+  if (!fs21.existsSync(file))
     return { agent: "omp", kind: "gauge" };
   let db;
   try {
@@ -6724,7 +7471,7 @@ function claudeQuotaFacts(sessions) {
   for (const session of sessions) {
     if (session.agentSessionId === undefined)
       continue;
-    const file = path19.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
+    const file = path21.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
     const event = parseClaudeLimitEvent(readTailLines(file, QUOTA_TAIL_BYTES));
     if (event && (!newest || event.at > newest.at))
       newest = event;
@@ -6756,11 +7503,11 @@ function collectQuotaFacts(agents, sessions, onPath) {
 function storeQuietForMs(agent, cwd, agentSessionId, nowMs) {
   if (agentSessionId === undefined)
     return;
-  const file = agent === "claude" ? path19.join(claudeConfigDir2(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
+  const file = agent === "claude" ? path21.join(claudeConfigDir2(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
   if (file === undefined)
     return;
   try {
-    return Math.max(0, nowMs - fs19.statSync(file).mtimeMs);
+    return Math.max(0, nowMs - fs21.statSync(file).mtimeMs);
   } catch {
     return;
   }
@@ -6770,15 +7517,15 @@ function readFileRange(file, from, to) {
     return "";
   let fd;
   try {
-    fd = fs19.openSync(file, "r");
+    fd = fs21.openSync(file, "r");
     const buffer = Buffer.allocUnsafe(to - from);
-    const read = fs19.readSync(fd, buffer, 0, to - from, from);
+    const read = fs21.readSync(fd, buffer, 0, to - from, from);
     return buffer.subarray(0, read).toString("utf8");
   } catch {
     return "";
   } finally {
     if (fd !== undefined)
-      fs19.closeSync(fd);
+      fs21.closeSync(fd);
   }
 }
 var QUOTA_TAIL_BYTES;
@@ -11229,15 +11976,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 path20 from "path";
+import fs22 from "fs";
+import path22 from "path";
 
 class PtySession {
   info;
   pty;
-  term;
-  serializeAddon;
+  mirror;
   dataListeners = new Set;
   exitListeners = new Set;
   saveTimer;
@@ -11254,26 +12041,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 +12102,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)
@@ -11351,10 +12124,10 @@ class PtySession {
   }
   saveScrollback() {
     try {
-      const file = path20.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
+      const file = path22.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
       const tmp = `${file}.tmp`;
-      fs20.writeFileSync(tmp, this.serializeBuffer(), "utf8");
-      fs20.renameSync(tmp, file);
+      fs22.writeFileSync(tmp, this.serializeBuffer(), "utf8");
+      fs22.renameSync(tmp, file);
     } catch (err) {
       log(`scrollback save failed for ${this.info.shortId}: ${String(err)}`);
     }
@@ -11365,20 +12138,20 @@ 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 os7 from "os";
-import path21 from "path";
+import { spawn as spawn5 } from "child_process";
+import fs23 from "fs";
+import os8 from "os";
+import path23 from "path";
 function sessionScratchRoot(info) {
   return info.worktreePath ?? info.cwd;
 }
@@ -11420,11 +12193,23 @@ 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";
+  }
+}
+function ptyHostEnabled(env) {
+  return env["AXTERM_PTY_HOST"] !== "0";
+}
 
 class SessionManager {
   store;
   hooks;
   configuredDefaults;
+  ptyHostPolicy;
   live = new Map;
   agentRuntime = new Map;
   injector = new Injector;
@@ -11432,18 +12217,66 @@ class SessionManager {
   eventListeners = new Set;
   rawHookListeners = new Set;
   workspace = new LocalWorkspace(MATERIALISED_DIR);
-  constructor(store, hooks, configuredDefaults = () => ({})) {
+  constructor(store, hooks, configuredDefaults = () => ({}), ptyHostPolicy = {
+    enabled: ptyHostEnabled(process.env),
+    ...process.env["AXTERM_PTY_HOST_MAIN"] ? { mainScript: process.env["AXTERM_PTY_HOST_MAIN"] } : {}
+  }) {
     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.ptyHostPolicy = ptyHostPolicy;
     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 (!this.ptyHostPolicy.enabled)
+      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) {
@@ -11517,13 +12350,14 @@ class SessionManager {
     return {
       stat: await diffStat(ws, target, compare),
       files: await changedFiles(ws, target, compare),
+      patch: await diffPatch(ws, target, compare),
       base: compare,
       ...info.branch !== undefined ? { branch: info.branch } : {}
     };
   }
   async create(params) {
-    const requestedCwd = params.cwd ? path21.resolve(params.cwd) : os7.homedir();
-    if (!fs21.existsSync(requestedCwd)) {
+    const requestedCwd = params.cwd ? path23.resolve(params.cwd) : os8.homedir();
+    if (!fs23.existsSync(requestedCwd)) {
       throw new AxtermError("err.cwd.missing", { cwd: requestedCwd });
     }
     let worktree;
@@ -11567,11 +12401,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 && fs23.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 ?? path23.basename(sessionCwd),
+      cwd: sessionCwd,
       shell: shell.kind,
       agentCommand,
       state: "running",
@@ -11580,8 +12430,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 +12444,7 @@ class SessionManager {
       launchToken
     });
     const file = this.claudeSettingsPath(id);
-    fs21.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
+    fs23.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
   }
   writeGeminiSettings(sessionId) {
     try {
@@ -11608,69 +12457,104 @@ class SessionManager {
       });
       const file = this.geminiSettingsPath();
       const tmp = `${file}.tmp`;
-      fs21.writeFileSync(tmp, JSON.stringify(settings, null, 2));
-      fs21.renameSync(tmp, file);
+      fs23.writeFileSync(tmp, JSON.stringify(settings, null, 2));
+      fs23.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);
+      fs23.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 path23.join(RUNTIME_DIR, `codex-app-${id}.json`);
+  }
+  adoptCodexAppServer(id) {
+    const file = this.codexAppServerFile(id);
+    let record;
+    try {
+      record = JSON.parse(fs23.readFileSync(file, "utf8"));
+    } catch {
+      return;
+    }
+    const pid = record.pid;
+    const url = record.url;
+    if (typeof pid !== "number" || typeof url !== "string")
+      return;
+    if (!pidIsRunning(pid)) {
+      fs23.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);
+        fs23.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 });
+    const home = path23.join(STATE_DIR, "codex-home");
+    fs23.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);
+    fs23.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
+    fs23.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 configPath = path23.join(home, "config.toml");
+    const existing = fs23.existsSync(configPath) ? fs23.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(`
+      fs23.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
 `) ? `
 ${block}` : block);
     }
@@ -11683,50 +12567,50 @@ ${block}` : block);
     return home;
   }
   linkCodexAuth(home) {
-    const target = path21.join(home, "auth.json");
-    if (fs21.existsSync(target))
+    const target = path23.join(home, "auth.json");
+    if (fs23.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))
+    const operatorHome = process.env["CODEX_HOME"] ?? path23.join(os8.homedir(), ".codex");
+    const source = path23.join(operatorHome, "auth.json");
+    if (!fs23.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() {
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
-    const home = path21.join(STATE_DIR, "codex-home");
-    const operatorHome = process.env["CODEX_HOME"] ?? path21.join(os7.homedir(), ".codex");
-    const authSource = path21.join(operatorHome, "auth.json");
+    const home = path23.join(STATE_DIR, "codex-home");
+    const operatorHome = process.env["CODEX_HOME"] ?? path23.join(os8.homedir(), ".codex");
+    const authSource = path23.join(operatorHome, "auth.json");
     const geminiSettings = this.geminiSettingsPath();
-    const configPath = path21.join(home, "config.toml");
+    const configPath = path23.join(home, "config.toml");
     const read = (file) => {
       try {
-        return fs21.existsSync(file) ? fs21.readFileSync(file, "utf8") : undefined;
+        return fs23.existsSync(file) ? fs23.readFileSync(file, "utf8") : undefined;
       } catch {
         return;
       }
     };
     return [
-      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs21.existsSync(bridge.command) }),
+      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs23.existsSync(bridge.command) }),
       ...evaluateOmpDoctor({
         binary: lookupOnPath("omp"),
         extensionPath: this.hooks.extensionPath,
-        extensionExists: fs21.existsSync(this.hooks.extensionPath)
+        extensionExists: fs23.existsSync(this.hooks.extensionPath)
       }),
       ...evaluateClaudeDoctor({ binary: lookupOnPath("claude") }),
       ...evaluateCodexDoctor({
         binary: lookupOnPath("codex"),
         authSourcePath: authSource,
-        authSourceExists: fs21.existsSync(authSource),
-        homeExists: fs21.existsSync(home),
+        authSourceExists: fs23.existsSync(authSource),
+        homeExists: fs23.existsSync(home),
         expected: codexHookTrust(codexTrustKeyPath(home), buildCodexHooks({ command: bridge.command, args: bridge.args })),
         configToml: read(configPath)
       }),
@@ -11825,6 +12709,22 @@ ${block}` : block);
     session.write(digit);
     return true;
   }
+  answerScreenChoice(idOrPrefix, optionIndex) {
+    const session = this.resolveLive(idOrPrefix);
+    const agent = agentIdFromCommand(session.info.agentCommand);
+    const dialog = detectOnboarding(agent, session.screenText(30));
+    const digit = dialog?.options[optionIndex]?.digit;
+    if (digit === undefined) {
+      const keys2 = menuChoiceKeys(agentProfile(agent), optionIndex);
+      if (keys2 === undefined)
+        throw new AxtermError("err.choose.noSafeKey", { agent, index: optionIndex });
+      session.write(keys2);
+      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;
@@ -11851,13 +12751,13 @@ ${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 });
+    const file = path23.join(path23.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
+    fs23.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 });
+      fs23.rmSync(path23.join(path23.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
     } catch {}
   }
   async stageInboundFile(idOrPrefix, suggestedName, bytes) {
@@ -11866,20 +12766,20 @@ ${block}` : block);
       return this.stageInRuntimeDir(info, suggestedName, bytes);
     const ws = this.workspaceFor(info.id);
     const dir = sessionScratchRoot(info);
-    const file = path21.resolve(planMaterialisedPath(inboundStagingDir(dir), info.id, suggestedName));
+    const file = path23.resolve(planMaterialisedPath(inboundStagingDir(dir), info.id, suggestedName));
     await this.prepareScratchDir(ws, dir, file);
     await ws.write(file, bytes, 384);
-    log(`session ${info.shortId} staged ${path21.basename(file)} (${bytes.byteLength} bytes)`);
+    log(`session ${info.shortId} staged ${path23.basename(file)} (${bytes.byteLength} bytes)`);
     return file;
   }
   stagingMode() {
     return this.configuredDefaults().staging ?? "project";
   }
   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 });
-    log(`session ${info.shortId} staged ${path21.basename(file)} (${bytes.byteLength} bytes, runtime dir)`);
+    const file = path23.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
+    await fs23.promises.mkdir(path23.dirname(file), { recursive: true, mode: 448 });
+    await fs23.promises.writeFile(file, bytes, { mode: 384 });
+    log(`session ${info.shortId} staged ${path23.basename(file)} (${bytes.byteLength} bytes, runtime dir)`);
     return file;
   }
   async prepareScratchDir(ws, sessionDir, file) {
@@ -11896,47 +12796,47 @@ ${block}` : block);
       throw new AxtermError("err.staging.notIgnored", { dir: scratch, file: SCRATCH_IGNORE_NAME });
     }
     try {
-      await ws.mkdirp(path21.dirname(file), 448);
+      await ws.mkdirp(path23.dirname(file), 448);
     } catch (err) {
       throw new AxtermError("err.staging.dir", { dir: scratch, error: err instanceof Error ? err.message : String(err) });
     }
   }
   removeStagedFiles(id, info) {
     try {
-      fs21.rmSync(path21.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+      fs23.rmSync(path23.join(MATERIALISED_DIR, id), { recursive: true, force: true });
     } catch {}
     if (info === undefined)
       return;
-    const scratch = path21.resolve(scratchDir(sessionScratchRoot(info)));
+    const scratch = path23.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);
+      fs23.rmSync(path23.resolve(inboundStagingDir(sessionScratchRoot(info)), id), { recursive: true, force: true });
+      fs23.rmdirSync(path23.join(scratch, "inbound"));
+      fs23.rmSync(path23.join(scratch, SCRATCH_IGNORE_NAME), { force: true });
+      fs23.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 });
+      fs23.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs23.rmSync(this.mcpConfigPath(id), { force: true });
+      fs23.rmSync(this.mcpContextPath(id), { force: true });
+      fs23.rmSync(this.geminiTelemetryPath(id), { force: true });
       this.stopCodexAppServer(id);
     } catch {}
   }
   claudeSettingsPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `claude-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `claude-${id}.json`);
   }
   mcpConfigPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
   }
   mcpContextPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
   }
   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 });
+      fs23.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 +12849,7 @@ ${block}` : block);
   writeMcpConfig(id, contextPath) {
     const file = this.mcpConfigPath(id);
     try {
-      fs21.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
+      fs23.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)}`);
@@ -11957,27 +12857,29 @@ ${block}` : block);
     }
   }
   geminiTelemetryPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
   }
   geminiSettingsPath() {
-    return path21.join(path21.dirname(this.hooks.endpointFile), "gemini-defaults.json");
+    return path23.join(path23.dirname(this.hooks.endpointFile), "gemini-defaults.json");
   }
   async ptySpawner() {
-    if (process.env["AXTERM_PTY_HOST"] !== "1" || this.ptyHostUnavailable)
-      return spawnPty;
+    if (!this.ptyHostPolicy.enabled || this.ptyHostUnavailable)
+      return { spawn: spawnPty, hostOwned: false };
     try {
       if (this.ptyHost === undefined) {
-        const override = process.env["AXTERM_PTY_HOST_MAIN"];
-        const info = await ensurePtyHost({ runtimeDir: RUNTIME_DIR, ...override ? { mainScript: override } : {} });
+        const info = await ensurePtyHost({
+          runtimeDir: RUNTIME_DIR,
+          ...this.ptyHostPolicy.mainScript ? { mainScript: this.ptyHostPolicy.mainScript } : {}
+        });
         this.ptyHost = await connectPtyHost({ endpoint: info.endpoint, token: info.token });
         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 +12890,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 +12898,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 +12921,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 +12932,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 +12967,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;
@@ -12119,7 +13035,7 @@ ${block}` : block);
       this.store.updateAgentState(id, result.entry.state, "hook", now);
       log(`session ${info.shortId} agent ${runtime.entry?.state ?? "-"} -> ${result.entry.state}`);
       this.emit({ t: "agent.status", sessionId: id, state: result.entry.state, toolName: result.entry.toolName });
-      if (result.entry.state === "blocked" && agentProfile(agentIdFromCommand(info.agentCommand)).structuredApprovals !== true) {
+      if (offersKeystrokeApproval(agentProfile(agentIdFromCommand(info.agentCommand)), result.entry.state)) {
         runtime.choiceSeq += 1;
         this.emit({
           t: "choice.request",
@@ -12226,38 +13142,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 +13160,7 @@ ${block}` : block);
     if (agentCommand === undefined) {
       throw new AxtermError("err.session.noResumeSupport", { agent: profile.displayName });
     }
-    if (!fs21.existsSync(stored.cwd))
+    if (!fs23.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const info = { ...stored, agentCommand, state: "running" };
     delete info.exitCode;
@@ -12276,8 +13168,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 +13234,7 @@ ${block}` : block);
   removeScrollback(id) {
     for (const file of [`${id}.bin`, `${id}.bin.tmp`]) {
       try {
-        fs21.rmSync(path21.join(SCROLLBACK_DIR, file), { force: true });
+        fs23.rmSync(path23.join(SCROLLBACK_DIR, file), { force: true });
       } catch {}
     }
   }
@@ -12351,6 +13242,14 @@ ${block}` : block);
     this.drainGeminiTelemetry();
     this.watchForStalls();
   }
+  skipGeminiTelemetryHistory(id) {
+    const runtime = this.agentRuntime.get(id);
+    if (runtime === undefined)
+      return;
+    try {
+      runtime.telemetryOffset = fs23.statSync(this.geminiTelemetryPath(id)).size;
+    } catch {}
+  }
   drainGeminiTelemetry() {
     for (const [id, session] of this.live) {
       if (agentIdFromCommand(session.info.agentCommand) !== "gemini")
@@ -12361,7 +13260,7 @@ ${block}` : block);
       const file = this.geminiTelemetryPath(id);
       let size = 0;
       try {
-        size = fs21.statSync(file).size;
+        size = fs23.statSync(file).size;
       } catch {
         continue;
       }
@@ -12423,10 +13322,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 +13341,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();
@@ -12450,7 +13356,7 @@ var init_session_manager = __esm(() => {
   init_pty_session();
   init_shell();
   init_workspace_local();
-  MATERIALISED_DIR = path21.join(RUNTIME_DIR, "materialised");
+  MATERIALISED_DIR = path23.join(RUNTIME_DIR, "materialised");
   PROMPT_OPTIONS = {
     hostKey: [{ label: "yes" }, { label: "no" }],
     password: [],
@@ -12481,6 +13387,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 +13508,11 @@ var init_acknowledge = __esm(() => {
 });
 
 // packages/channel-telegram/src/attach.ts
-import fs22 from "fs";
-import path22 from "path";
+import fs24 from "fs";
+import path24 from "path";
 function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELEGRAM_LIMITS) {
-  const name = path22.basename(filePath);
-  const bytes = fs22.statSync(filePath).size;
+  const name = path24.basename(filePath);
+  const bytes = fs24.statSync(filePath).size;
   const plan = planAttachment({ name, bytes }, limits);
   if (plan.kind === "rejected")
     throw new Error(plan.reason);
@@ -12613,7 +13522,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([fs24.readFileSync(filePath)]), name);
   return { method: plan.kind === "photo" ? "sendPhoto" : "sendDocument", field, form };
 }
 function isPhotoRejection(error) {
@@ -12621,13 +13530,13 @@ function isPhotoRejection(error) {
   return /IMAGE_PROCESS_FAILED|PHOTO_INVALID_DIMENSIONS|PHOTO_EXT_INVALID|PHOTO_SAVE_FILE_INVALID/i.test(message);
 }
 function asDocumentUpload(filePath, chatId, topicId, caption) {
-  const name = path22.basename(filePath);
+  const name = path24.basename(filePath);
   const form = new FormData;
   form.append("chat_id", String(chatId));
   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([fs24.readFileSync(filePath)]), name);
   return { method: "sendDocument", field: "document", form };
 }
 var TELEGRAM_LIMITS;
@@ -12697,6 +13606,31 @@ function planScreenDelivery(text, maxMessages) {
   const chunks = preChunks(text);
   return chunks.length <= maxMessages ? { kind: "messages", chunks } : { kind: "file", text };
 }
+function diffQuote(summary, limit = TELEGRAM_TEXT_LIMIT, reserved = 0) {
+  const OPEN = "<blockquote expandable><pre>";
+  const CLOSE = "</pre></blockquote>";
+  const budget = limit - reserved - OPEN.length - CLOSE.length;
+  const cut = (total) => escapeHtml(`\u2026 truncated, ${total} characters in the full patch`);
+  const rendered = [];
+  let used = 0;
+  let stopped = false;
+  for (const line of summary.lines) {
+    const marker = line.kind === "add" ? "+" : line.kind === "del" ? "-" : "";
+    const escaped = escapeHtml(`${marker}${line.text}`);
+    if (used + escaped.length + 1 + cut(summary.totalChars).length > budget) {
+      stopped = true;
+      break;
+    }
+    rendered.push(escaped);
+    used += escaped.length + 1;
+  }
+  if (rendered.length === 0)
+    return "";
+  if (stopped || summary.truncated !== undefined)
+    rendered.push(cut(summary.totalChars));
+  return `${OPEN}${rendered.join(`
+`)}${CLOSE}`;
+}
 function parseScreenLines(args) {
   const raw = args[0];
   if (raw === undefined || !/^-?\d+$/.test(raw))
@@ -13171,7 +14105,7 @@ var init_topic_title = __esm(() => {
 });
 
 // packages/channel-telegram/src/adapter.ts
-import { setTimeout as delay3 } from "timers/promises";
+import { setTimeout as delay4 } from "timers/promises";
 function readMedia(msg) {
   const photo = msg.photo?.at(-1);
   if (photo) {
@@ -13207,6 +14141,7 @@ class TelegramChannel {
   titleFlushes = new Map;
   flows = new Map;
   outbound = Promise.resolve();
+  username;
   polling = false;
   stopped = false;
   pollAbort;
@@ -13391,7 +14326,16 @@ class TelegramChannel {
       `${d.stat.filesChanged} files  +${d.stat.insertions}  -${d.stat.deletions}`,
       ...d.files.map((f) => `\u2022 ${f}`)
     ];
-    for (const message of htmlLines(lines)) {
+    const messages = htmlLines(lines);
+    const summary = d.patch === undefined ? undefined : summarizePatch(d.patch);
+    const last = messages.at(-1);
+    if (summary !== undefined && last !== undefined) {
+      const quote = diffQuote(summary, TELEGRAM_TEXT_LIMIT, last.length + 1);
+      if (quote !== "")
+        messages[messages.length - 1] = `${last}
+${quote}`;
+    }
+    for (const message of messages) {
       await this.sendToSession(sessionId, message);
     }
   }
@@ -13523,6 +14467,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 +14650,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;
@@ -13792,8 +14758,8 @@ ${code(prompt.line)}`,
         throw new Error("this Telegram client cannot download files");
       const files = [];
       for (const item of batch.items) {
-        const path23 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
-        files.push({ path: path23, kind: item.kind });
+        const path25 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
+        files.push({ path: path25, kind: item.kind });
       }
       await this.control.prompt(batch.sessionId, buildAttachmentPrompt(files, batch.caption));
       this.log(`staged ${files.length} inbound file(s) for ${batch.sessionId}`);
@@ -13808,7 +14774,7 @@ ${code(prompt.line)}`,
   async settleInboundForTest() {
     while (this.albums.size > 0 || this.inboundQueues.size > 0) {
       if (this.albums.size > 0)
-        await delay3(this.albumDebounceMs + 5);
+        await delay4(this.albumDebounceMs + 5);
       await Promise.all([...this.inboundQueues.values()]);
     }
   }
@@ -13817,10 +14783,22 @@ ${code(prompt.line)}`,
       return;
     await this.api.call("setMessageReaction", { chat_id: chatId, message_id: messageId, reaction: reactionPayload(state) }).catch(() => {});
   }
+  async selfUsername() {
+    if (this.username !== undefined)
+      return this.username;
+    try {
+      const me = await this.api.call("getMe");
+      if (typeof me.username === "string" && me.username.length > 0)
+        this.username = me.username;
+    } catch {}
+    return this.username;
+  }
   async handleCommand(text, binding, msg) {
     const [rawCmd = "", ...args] = text.split(/\s+/);
     const rawTail = text.slice(rawCmd.length);
-    const cmd = rawCmd.replace(/@\w+$/, "");
+    const { command: cmd, target } = parseCommandAddress(rawCmd);
+    if (target !== undefined && !commandIsForBot(target, await this.selfUsername()))
+      return;
     if (binding) {
       switch (cmd) {
         case "/esc":
@@ -13916,8 +14894,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": {
@@ -13969,13 +14954,13 @@ ${code(prompt.line)}`,
         const project = await resolveProject(args[0]);
         if (!project)
           return;
-        const target = args[1];
-        if (target === undefined) {
+        const target2 = args[1];
+        if (target2 === undefined) {
           await reply(t("tg.usage.rm"));
           return;
         }
-        const result = await this.control.removeWorktree(project.alias, target, args[2] === "force");
-        await reply(result.removed ? t("tg.worktree.removed", { target }) : t("tg.worktree.refused", { reason: String(result.reason) }));
+        const result = await this.control.removeWorktree(project.alias, target2, args[2] === "force");
+        await reply(result.removed ? t("tg.worktree.removed", { target: target2 }) : t("tg.worktree.refused", { reason: String(result.reason) }));
         return;
       }
       case "/sessions": {
@@ -14073,8 +15058,12 @@ ${code(prompt.line)}`,
       return;
     }
     if (flow.askId === undefined) {
-      const keys2 = agentProfile(agentIdFromCommand(session.agentCommand)).approvalKeys;
-      this.control.write(session.id, keys2 !== undefined && decoded.optionIndex <= 1 ? decoded.optionIndex === 0 ? keys2.allow : keys2.deny : buildMenuSelectKeys(decoded.optionIndex));
+      const keys2 = menuChoiceKeys(agentProfile(agentIdFromCommand(session.agentCommand)), decoded.optionIndex);
+      if (keys2 === undefined) {
+        await answer(t("tg.answer.noSafeKey"));
+        return;
+      }
+      this.control.write(session.id, keys2);
     }
     flow.answers.push({ questionIndex: flow.cursor, selected: [label] });
     flow.cursor += 1;
@@ -14127,6 +15116,11 @@ ${code(prompt.line)}`,
       clearTimeout(album.timer);
     this.albums.clear();
   }
+  pollHealth() {
+    return this.pollError;
+  }
+  pollError;
+  pollWarned = false;
   async pollLoop() {
     while (this.polling) {
       try {
@@ -14137,6 +15131,10 @@ ${code(prompt.line)}`,
         });
         if (this.stopped)
           return;
+        if (this.pollError !== undefined)
+          this.log("polling recovered");
+        this.pollError = undefined;
+        this.pollWarned = false;
         for (const update2 of updates) {
           this.updateOffset = Math.max(this.updateOffset, update2.update_id + 1);
           await this.handleUpdate(update2);
@@ -14146,11 +15144,29 @@ ${code(prompt.line)}`,
       } catch (err) {
         if (!this.polling)
           return;
-        this.log(`poll failed: ${String(err)}`);
-        await delay3(3000);
+        const reason = String(err);
+        this.pollError = reason;
+        this.log(`poll failed: ${reason}`);
+        if (!this.pollWarned) {
+          this.pollWarned = true;
+          this.warnPollFailure(reason);
+        }
+        await delay4(3000);
       }
     }
   }
+  async warnPollFailure(reason) {
+    const conflict = /\b409\b|terminated by other getUpdates/i.test(reason);
+    const text = conflict ? tHtml("tg.poll.conflict", { machine: this.config.machine.name }) : tHtml("tg.poll.failed", { machine: this.config.machine.name, reason: oneLineReason(reason) });
+    try {
+      await this.api.call("sendMessage", { chat_id: this.config.groupId, text, parse_mode: "HTML" });
+    } catch (err) {
+      this.log(`could not report the poll failure: ${String(err)}`);
+    }
+  }
+}
+function oneLineReason(reason) {
+  return reason.replace(/\s+/g, " ").trim().slice(0, 200);
 }
 var SCREEN_MESSAGE_BUDGET = 2, AGENT_ERROR_CHARS = 1200, RAW_TYPE_LIMIT = 500, RAW_SCREEN_LINES = 12, HELP_KEYS, helpText = () => HELP_KEYS.map((key) => escapeHtml(t(key))).join(`
 `), ALBUM_DEBOUNCE_MS = 2000, UNKNOWN_SIZE = 1, REFUSAL_KEYS, megabytes2 = (bytes) => `${Math.round(bytes / (1024 * 1024))} MB`;
@@ -14187,13 +15203,13 @@ var init_src2 = __esm(() => {
 });
 
 // packages/daemon/src/machine-identity.ts
-import os8 from "os";
+import os9 from "os";
 function resolveMachineIdentity(override) {
-  const hostname = os8.hostname();
+  const hostname = os9.hostname();
   return {
     name: slugifyMachineName(override && override.trim().length > 0 ? override : hostname),
     hostname,
-    addresses: collectAddresses(os8.networkInterfaces())
+    addresses: collectAddresses(os9.networkInterfaces())
   };
 }
 var init_machine_identity = __esm(() => {
@@ -14205,13 +15221,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 +15278,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 +15293,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],
@@ -14383,6 +15401,9 @@ class TelegramService {
       problems.push(t("doctor.noUser"));
     if (problems.length > 0)
       return { ok: false, problems };
+    const pollError = this.channel?.pollHealth();
+    if (pollError !== undefined)
+      problems.push(t("doctor.telegram.pollFailing", { reason: pollError.replace(/\s+/g, " ").slice(0, 160) }));
     const api = new FetchTelegramApi(s.botToken);
     const report = { ok: true, problems };
     try {
@@ -14423,7 +15444,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 fs25 from "fs";
 import net5 from "net";
 function isPidAlive(pid) {
   try {
@@ -14435,9 +15456,9 @@ function isPidAlive(pid) {
 }
 async function main() {
   ensureDataDirs();
-  if (fs23.existsSync(RUNTIME_FILE2)) {
+  if (fs25.existsSync(RUNTIME_FILE2)) {
     try {
-      const existing = JSON.parse(fs23.readFileSync(RUNTIME_FILE2, "utf8"));
+      const existing = JSON.parse(fs25.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 +15481,7 @@ async function main() {
     version: productVersion(),
     startedAt: Date.now()
   };
-  fs23.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
+  fs25.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 +15533,15 @@ async function main() {
     hookHost.stop();
     store.close();
     try {
-      const current = JSON.parse(fs23.readFileSync(RUNTIME_FILE2, "utf8"));
+      const current = JSON.parse(fs25.readFileSync(RUNTIME_FILE2, "utf8"));
       if (current.pid === process.pid)
-        fs23.rmSync(RUNTIME_FILE2);
+        fs25.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,
@@ -14530,12 +15554,9 @@ async function main() {
   });
   process.on("SIGINT", () => stop("SIGINT"));
   process.on("SIGTERM", () => stop("SIGTERM"));
-  process.on("uncaughtException", (err) => {
-    log(`uncaughtException: ${err.stack ?? String(err)}`);
-    stop("uncaughtException");
-  });
   log(`daemon started pid=${process.pid} config=${CONFIG_DIR} state=${STATE_DIR}`);
 }
+var crashGuards;
 var init_src3 = __esm(() => {
   init_src();
   init_config_migrate();
@@ -14548,7 +15569,12 @@ var init_src3 = __esm(() => {
   init_telegram_service();
   init_store();
   net5.setDefaultAutoSelectFamilyAttemptTimeout(3000);
-  main();
+  crashGuards = new ProcessCrashGuards({
+    log,
+    exit: (code2) => process.exit(code2)
+  });
+  crashGuards.install(process);
+  main().catch((reason) => crashGuards.startupFailed(reason));
 });
 
 // packages/daemon/src/pty-host.ts
@@ -14603,7 +15629,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 +15646,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 +15672,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 +15694,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 +15725,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,8 +15784,8 @@ var init_pty_host_main = __esm(() => {
 
 // packages/cli/src/index.ts
 init_src();
-import fs24 from "fs";
-import path23 from "path";
+import fs26 from "fs";
+import path25 from "path";
 
 // packages/cli/src/attach.ts
 import fs from "fs";
@@ -15150,11 +16204,11 @@ ${bold(t(state.promptKey))} ${dim("[yes]")} `);
   const finished = advance({ ...state, kind: "review", step: "review" }, "");
   if (!("done" in finished))
     return { saved: false };
-  for (const [path3, value] of finished.done.settings) {
-    await client.call("config.set", { path: path3, value });
+  for (const [path4, value] of finished.done.settings) {
+    await client.call("config.set", { path: path4, value });
   }
-  for (const [path3, value] of finished.done.secrets) {
-    await client.call("config.set", { path: path3, value });
+  for (const [path4, value] of finished.done.secrets) {
+    await client.call("config.set", { path: path4, value });
   }
   stdout.write(`
 ${green("\u2713")} ${t("wizard.saved")}
@@ -15192,10 +16246,202 @@ function describeHealth(health) {
 // packages/cli/src/client.ts
 init_src();
 import { spawn } from "child_process";
-import fs2 from "fs";
+import fs3 from "fs";
 import net from "net";
-import path3 from "path";
+import path5 from "path";
 import { setTimeout as delay } from "timers/promises";
+
+// packages/cli/src/service-manager.ts
+init_src();
+import { spawnSync } from "child_process";
+import fs2 from "fs";
+import os3 from "os";
+import path4 from "path";
+
+class ServiceCommandError extends Error {
+  invocation;
+  result;
+  constructor(invocation, result) {
+    super(result.stderr.trim() || result.stdout.trim() || `${invocation.command} exited ${result.status}`);
+    this.invocation = invocation;
+    this.result = result;
+    this.name = "ServiceCommandError";
+  }
+}
+var defaultRun = ({ command, args }) => {
+  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
+  };
+};
+function writeAtomic(file, contents) {
+  fs2.mkdirSync(path4.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp`;
+  try {
+    fs2.writeFileSync(tmp, contents, { mode: 384 });
+    fs2.renameSync(tmp, file);
+    if (process.platform !== "win32")
+      fs2.chmodSync(file, 384);
+  } catch (err) {
+    try {
+      fs2.rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+function utf16Xml(contents) {
+  return Buffer.concat([Buffer.from([255, 254]), Buffer.from(contents, "utf16le")]);
+}
+function utf8Script(contents) {
+  return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(contents, "utf8")]);
+}
+
+class ServiceManager {
+  options;
+  definition;
+  run;
+  uid;
+  constructor(options) {
+    this.options = options;
+    this.run = options.run ?? defaultRun;
+    this.uid = options.uid ?? process.getuid?.();
+    this.definition = serviceDefinition({
+      platform: options.platform,
+      launch: options.launch,
+      homeDir: options.homeDir,
+      stateDir: options.stateDir,
+      ...options.userId ? { userId: options.userId } : {},
+      ...options.environment ? { environment: options.environment } : {}
+    });
+  }
+  install() {
+    fs2.mkdirSync(path4.join(this.options.stateDir, "logs"), { recursive: true, mode: 448 });
+    for (const companion of this.definition.companionFiles ?? []) {
+      writeAtomic(companion.file, this.definition.kind === "task-scheduler" ? utf8Script(companion.contents) : companion.contents);
+    }
+    writeAtomic(this.definition.file, this.definition.kind === "task-scheduler" ? utf16Xml(this.definition.contents) : this.definition.contents);
+    if (this.definition.kind === "systemd") {
+      this.must({ command: "systemctl", args: ["--user", "daemon-reload"] });
+      this.must({ command: "systemctl", args: ["--user", "enable", SYSTEMD_SERVICE] });
+    } else if (this.definition.kind === "launchd") {
+      this.must({ command: "launchctl", args: ["enable", this.launchdTarget()] });
+    } else {
+      this.must({ command: "schtasks.exe", args: ["/Create", "/TN", WINDOWS_TASK, "/XML", this.definition.file, "/F"] });
+    }
+  }
+  start() {
+    if (this.definition.kind === "systemd") {
+      this.must({ command: "systemctl", args: ["--user", "start", SYSTEMD_SERVICE] });
+    } else if (this.definition.kind === "launchd") {
+      const target = this.launchdTarget();
+      const loaded = this.run({ command: "launchctl", args: ["print", target] }).status === 0;
+      this.must(loaded ? { command: "launchctl", args: ["kickstart", target] } : { command: "launchctl", args: ["bootstrap", `gui/${this.requireUid()}`, this.definition.file] });
+    } else {
+      this.must({ command: "schtasks.exe", args: ["/Run", "/TN", WINDOWS_TASK] });
+    }
+  }
+  status() {
+    if (this.definition.kind === "systemd") {
+      return {
+        kind: this.definition.kind,
+        installed: fs2.existsSync(this.definition.file),
+        active: this.run({ command: "systemctl", args: ["--user", "is-active", "--quiet", SYSTEMD_SERVICE] }).status === 0
+      };
+    }
+    if (this.definition.kind === "launchd") {
+      return {
+        kind: this.definition.kind,
+        installed: fs2.existsSync(this.definition.file),
+        active: this.run({ command: "launchctl", args: ["print", this.launchdTarget()] }).status === 0
+      };
+    }
+    const installed = this.run({ command: "schtasks.exe", args: ["/Query", "/TN", WINDOWS_TASK] }).status === 0;
+    const active = installed && this.run({
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `if ((Get-ScheduledTask -TaskName '${WINDOWS_TASK}').State -eq 'Running') { exit 0 } else { exit 1 }`
+      ]
+    }).status === 0;
+    return { kind: this.definition.kind, installed, active };
+  }
+  uninstall() {
+    if (this.definition.kind === "systemd") {
+      this.run({ command: "systemctl", args: ["--user", "disable", SYSTEMD_SERVICE] });
+      fs2.rmSync(this.definition.file, { force: true });
+      this.must({ command: "systemctl", args: ["--user", "daemon-reload"] });
+    } else if (this.definition.kind === "launchd") {
+      this.run({ command: "launchctl", args: ["disable", this.launchdTarget()] });
+      fs2.rmSync(this.definition.file, { force: true });
+    } else {
+      this.run({ command: "schtasks.exe", args: ["/Delete", "/TN", WINDOWS_TASK, "/F"] });
+      fs2.rmSync(this.definition.file, { force: true });
+    }
+    for (const companion of this.definition.companionFiles ?? [])
+      fs2.rmSync(companion.file, { force: true });
+  }
+  must(command) {
+    const result = this.run(command);
+    if (result.status !== 0)
+      throw new ServiceCommandError(command, result);
+  }
+  requireUid() {
+    if (this.uid === undefined)
+      throw new Error("launchd requires the current uid");
+    return this.uid;
+  }
+  launchdTarget() {
+    return `gui/${this.requireUid()}/${LAUNCHD_LABEL}`;
+  }
+}
+function windowsUserId(run = defaultRun) {
+  const command = {
+    command: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"
+    ]
+  };
+  const result = run(command);
+  const value = result.stdout.trim();
+  if (result.status !== 0 || value === "")
+    throw new ServiceCommandError(command, result);
+  return value;
+}
+function startInstalledService(manager) {
+  if (!manager.status().installed)
+    return false;
+  manager.start();
+  return true;
+}
+function currentServiceManager(run = defaultRun) {
+  const paths = resolvePaths(currentPathEnv());
+  const environment = {};
+  if (process.env["AXTERM_CONFIG_DIR"] === paths.configDir)
+    environment["AXTERM_CONFIG_DIR"] = paths.configDir;
+  if (process.env["AXTERM_STATE_DIR"] === paths.stateDir)
+    environment["AXTERM_STATE_DIR"] = paths.stateDir;
+  if (process.env["AXTERM_RUNTIME_DIR"] === paths.runtimeDir)
+    environment["AXTERM_RUNTIME_DIR"] = paths.runtimeDir;
+  return new ServiceManager({
+    platform: process.platform,
+    homeDir: os3.homedir(),
+    stateDir: paths.stateDir,
+    launch: daemonLaunch({ execPath: process.execPath, mainScript: Bun.main }),
+    ...process.getuid ? { uid: process.getuid() } : {},
+    ...process.platform === "win32" ? { userId: windowsUserId(run) } : {},
+    ...Object.keys(environment).length > 0 ? { environment } : {},
+    run
+  });
+}
+
+// packages/cli/src/client.ts
 var RUNTIME_FILE = resolvePaths(currentPathEnv()).runtimeFile;
 
 class RpcClient {
@@ -15281,7 +16527,7 @@ class RpcClient {
 }
 function readRuntime() {
   try {
-    const runtime = JSON.parse(fs2.readFileSync(RUNTIME_FILE, "utf8"));
+    const runtime = JSON.parse(fs3.readFileSync(RUNTIME_FILE, "utf8"));
     process.kill(runtime.pid, 0);
     return runtime;
   } catch {
@@ -15300,11 +16546,14 @@ async function tryConnect() {
     return;
   }
 }
+function connectDaemonIfRunning() {
+  return tryConnect();
+}
 function daemonEnv(cwd, env) {
   const files = [];
   for (const name of dotenvCandidates(env["NODE_ENV"])) {
     try {
-      files.push(parseDotenv(fs2.readFileSync(path3.join(cwd, name), "utf8")));
+      files.push(parseDotenv(fs3.readFileSync(path5.join(cwd, name), "utf8")));
     } catch {}
   }
   return scrubDotenvKeys(env, files);
@@ -15313,14 +16562,26 @@ async function ensureDaemon() {
   const existing = await tryConnect();
   if (existing)
     return existing;
-  const launch = daemonLaunch({ execPath: process.execPath, mainScript: Bun.main });
-  const child = spawn(launch.command, launch.args, {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-    env: daemonEnv(process.cwd(), process.env)
-  });
-  child.unref();
+  let supervised = false;
+  try {
+    supervised = startInstalledService(currentServiceManager());
+  } catch (err) {
+    if (err instanceof ServiceCommandError) {
+      const command = [err.invocation.command, ...err.invocation.args].join(" ");
+      throw new Error(t("cli.service.commandFailed", { command, error: err.message }));
+    }
+    throw err;
+  }
+  if (!supervised) {
+    const launch = daemonLaunch({ execPath: process.execPath, mainScript: Bun.main });
+    const child = spawn(launch.command, launch.args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: daemonEnv(process.cwd(), process.env)
+    });
+    child.unref();
+  }
   const deadline = Date.now() + 15000;
   while (Date.now() < deadline) {
     await delay(300);
@@ -15328,11 +16589,12 @@ async function ensureDaemon() {
     if (client)
       return client;
   }
-  throw new Error(t("cli.daemon.notReady", { log: path3.join(resolvePaths(currentPathEnv()).logDir, "daemon.log") }));
+  throw new Error(t("cli.daemon.notReady", { log: path5.join(resolvePaths(currentPathEnv()).logDir, "daemon.log") }));
 }
 
 // packages/cli/src/hook-bridge.ts
 init_src();
+import fs4 from "fs";
 var POST_TIMEOUT_MS = 1500;
 function isCodexApproval(agent, body) {
   if (agent !== "codex")
@@ -15357,24 +16619,44 @@ 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(fs4.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
 
 // packages/cli/src/mcp-server.ts
 init_src();
-import fs3 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path6 from "path";
 var ASK_TIMEOUT_MS = 10 * 60000;
 var POST_TIMEOUT_MS2 = 5000;
 var TOOLS = [
@@ -15490,7 +16772,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(fs5.readFileSync(contextFile, "utf8"));
         if (context.port && context.token && context.sessionId) {
           return {
             url: `http://127.0.0.1:${context.port}`,
@@ -15535,7 +16817,7 @@ class McpServer {
     const target = this.target();
     if (!target)
       return { text: "axterm is not reachable from this session", isError: true };
-    const resolved = path4.isAbsolute(file) ? file : path4.resolve(this.io.cwd, file);
+    const resolved = path6.isAbsolute(file) ? file : path6.resolve(this.io.cwd, file);
     const caption = typeof args["caption"] === "string" ? args["caption"] : undefined;
     const res = await this.post("/hook/attach", { sessionId: target.sessionId, launchToken: target.launchToken, path: resolved, caption }, POST_TIMEOUT_MS2);
     if (!res)
@@ -15645,15 +16927,15 @@ function runMcpServer() {
 
 // packages/cli/src/update.ts
 init_src();
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs4 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 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.1",
   type: "module",
   bin: {
     axterm: "dist/cli.js"
@@ -15727,13 +17009,13 @@ function assetName(platform, arch, isMusl) {
 function usesMusl() {
   if (process.platform !== "linux")
     return false;
-  if (fs4.existsSync("/etc/alpine-release"))
+  if (fs6.existsSync("/etc/alpine-release"))
     return true;
-  const ldd = spawnSync("ldd", ["--version"], { encoding: "utf8" });
+  const ldd = spawnSync2("ldd", ["--version"], { encoding: "utf8" });
   return `${ldd.stdout ?? ""}${ldd.stderr ?? ""}`.toLowerCase().includes("musl");
 }
 function firstLine(command, args) {
-  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+  const result = spawnSync2(command, args, { encoding: "utf8", windowsHide: true });
   if (result.status !== 0)
     return;
   return result.stdout?.trim().split(/\r?\n/)[0]?.trim() || undefined;
@@ -15741,7 +17023,7 @@ function firstLine(command, args) {
 function detectOrigin(execPath) {
   const resolved = (() => {
     try {
-      return fs4.realpathSync(execPath);
+      return fs6.realpathSync(execPath);
     } catch {
       return execPath;
     }
@@ -15766,7 +17048,7 @@ function npmGlobalBin() {
   const prefix = firstLine("npm", ["prefix", "-g"]);
   if (prefix === undefined)
     return;
-  return process.platform === "win32" ? prefix : path5.join(prefix, "bin");
+  return process.platform === "win32" ? prefix : path7.join(prefix, "bin");
 }
 async function download(url, into) {
   const response = await fetch(url, { signal: AbortSignal.timeout(600000) });
@@ -15783,7 +17065,7 @@ function checksumFor(sums, asset) {
   return;
 }
 function sha256(file) {
-  return createHash2("sha256").update(fs4.readFileSync(file)).digest("hex");
+  return createHash2("sha256").update(fs6.readFileSync(file)).digest("hex");
 }
 function ask2(question) {
   if (stdin2.isTTY !== true)
@@ -15830,8 +17112,8 @@ 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 downloaded = path5.join(staging, asset);
+  const staging = fs6.mkdtempSync(`${process.execPath}.update-`);
+  const downloaded = path7.join(staging, asset);
   try {
     console.log(t("cli.update.downloading", { asset }));
     await download(`${base}/${asset}`, downloaded);
@@ -15844,8 +17126,8 @@ async function runUpdate(client, current, options) {
       return;
     }
     if (process.platform !== "win32")
-      fs4.chmodSync(downloaded, 493);
-    const reported = spawnSync(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
+      fs6.chmodSync(downloaded, 493);
+    const reported = spawnSync2(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
     if (reported !== latest.version) {
       console.error(t("cli.update.wrongVersion", { got: reported ?? "nothing", want: latest.version }));
       process.exitCode = 1;
@@ -15877,14 +17159,14 @@ async function runUpdate(client, current, options) {
     if (plan.stale > 0)
       console.log(t("cli.update.staleDaemon", { count: plan.stale }));
     for (const id of plan.resume) {
-      const result = spawnSync(process.execPath, ["resume", id, "--no-attach", "--no-setup"], { encoding: "utf8" });
+      const result = spawnSync2(process.execPath, ["resume", id, "--no-attach", "--no-setup"], { encoding: "utf8" });
       if (result.status === 0)
         console.log(t("cli.update.restored", { id }));
       else
         console.log(t("cli.update.restoreFailed", { id, reason: (result.stderr ?? "").trim() || "unknown" }));
     }
   } finally {
-    fs4.rmSync(staging, { recursive: true, force: true });
+    fs6.rmSync(staging, { recursive: true, force: true });
   }
 }
 function applySwap(target, downloaded) {
@@ -15893,20 +17175,88 @@ function applySwap(target, downloaded) {
   try {
     for (const step of steps) {
       if (step.op === "chmod")
-        fs4.chmodSync(step.from, 493);
+        fs6.chmodSync(step.from, 493);
       else if (step.op === "backup") {
-        fs4.renameSync(step.from, step.to);
+        fs6.renameSync(step.from, step.to);
         backup = step.to;
       } else
-        fs4.renameSync(step.from, step.to);
+        fs6.renameSync(step.from, step.to);
     }
   } catch (err) {
-    if (backup !== undefined && !fs4.existsSync(target))
-      fs4.renameSync(backup, target);
+    if (backup !== undefined && !fs6.existsSync(target))
+      fs6.renameSync(backup, target);
     throw err;
   }
 }
 
+// packages/cli/src/service-command.ts
+init_src();
+import { setTimeout as delay2 } from "timers/promises";
+var SERVICE_WAIT_MS = 15000;
+var SERVICE_POLL_MS = 200;
+async function waitForDaemon(deps, running) {
+  const sleep = deps.sleep ?? ((ms) => delay2(ms));
+  const now = deps.now ?? Date.now;
+  const deadline = now() + SERVICE_WAIT_MS;
+  for (;; ) {
+    const connected = await deps.connect();
+    if (running && connected !== undefined)
+      return connected;
+    connected?.close();
+    if (!running && connected === undefined)
+      return;
+    if (now() >= deadline)
+      throw new Error(t("cli.service.notReady"));
+    await sleep(SERVICE_POLL_MS);
+  }
+}
+function localizedStatus(status) {
+  return t("cli.service.status", {
+    kind: status.kind,
+    installed: t(status.installed ? "cli.service.yes" : "cli.service.no"),
+    active: t(status.active ? "cli.service.yes" : "cli.service.no")
+  });
+}
+function localizeCommandError(err) {
+  if (err instanceof ServiceCommandError) {
+    const command = [err.invocation.command, ...err.invocation.args].join(" ");
+    throw new Error(t("cli.service.commandFailed", { command, error: err.message }));
+  }
+  throw err;
+}
+async function runServiceCommand(subcommand, deps) {
+  const write = deps.write ?? console.log;
+  try {
+    if (subcommand === "status") {
+      write(localizedStatus(deps.manager.status()));
+      return;
+    }
+    if (subcommand === "uninstall") {
+      deps.manager.uninstall();
+      write(t("cli.service.uninstalled"));
+      return;
+    }
+    if (subcommand !== "install")
+      throw new Error(t("cli.usage.service"));
+    deps.manager.install();
+    const existing = await deps.connect();
+    if (existing !== undefined) {
+      try {
+        await existing.call("daemon.stop");
+      } finally {
+        existing.close();
+      }
+      await waitForDaemon(deps, false);
+    }
+    deps.manager.start();
+    const ready = await waitForDaemon(deps, true);
+    ready?.close();
+    write(t("cli.service.installed", { kind: deps.manager.definition.kind }));
+  } catch (err) {
+    localizeCommandError(err);
+  }
+}
+
 // packages/cli/src/index.ts
 var VERSION = package_default.version;
 var VALUE_FLAGS = new Set([
@@ -15975,7 +17325,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) => fs26.realpathSync.native(target);
 function scopedHere(sessions) {
   return sessionsInScope(sessions, process.cwd(), realPath);
 }
@@ -15988,7 +17338,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 fs26.readFileSync(file, "utf8").split(/\r?\n/)) {
       const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m)
         out[m[1]] = m[2].trim();
@@ -15999,7 +17349,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(fs26.readFileSync(file, "utf8"));
     return typeof raw.locale === "string" ? raw.locale : undefined;
   } catch {
     return;
@@ -16036,6 +17386,13 @@ async function main2() {
     console.log(help());
     return;
   }
+  if (command === "service") {
+    await runServiceCommand(positional[0] ?? "status", {
+      manager: currentServiceManager(),
+      connect: connectDaemonIfRunning
+    });
+    return;
+  }
   const client = await ensureDaemon();
   const health = await client.call("config.health").catch(() => {
     return;
@@ -16055,6 +17412,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 +17506,15 @@ 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((err) => {
+          if (!/unknown method/i.test(String(err)))
+            throw err;
+          throw new Error(t("cli.choose.daemonTooOld"));
+        });
         console.log(t("cli.session.selected", { index: indexArg }));
+        if (answered.answered === "onboarding")
+          console.log(t("cli.session.selectedDialog"));
         break;
       }
       case "setup": {
@@ -16226,8 +17590,8 @@ async function main2() {
       case "project": {
         const sub = positional[0] ?? "list";
         if (sub === "add") {
-          const dir = positional[1] ? path23.resolve(positional[1]) : process.cwd();
-          const alias = positional[2] ?? path23.basename(dir);
+          const dir = positional[1] ? path25.resolve(positional[1]) : process.cwd();
+          const alias = positional[2] ?? path25.basename(dir);
           const projects = await client.call("project.add", {
             alias,
             path: dir