@layorixinc/axterm 0.4.0 → 0.6.0

package/dist/cli.js

@@ -31,8 +31,169 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/core/src/agent-registry.ts
+function agentProfile(id) {
+  const known = PROFILES[id];
+  if (known)
+    return known;
+  return {
+    id,
+    displayName: id,
+    title: {
+      workingLabel: id,
+      permissionLabel: `${id} - action required`,
+      idleLabel: `${id} ready`
+    },
+    hostHookSource: id
+  };
+}
+function renderAgentTitle(profile, state, frame) {
+  if (state === undefined)
+    return;
+  const { title } = profile;
+  if (state === "working") {
+    if (title.synthesizeWorking === false)
+      return;
+    const spinner = SPINNER_FRAMES[(frame % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length];
+    return `${spinner} ${title.workingLabel}`;
+  }
+  if (title.synthesizeTerminal === false)
+    return;
+  return state === "done" ? title.idleLabel : title.permissionLabel;
+}
+function oscTitle(title) {
+  const safe = title.replace(/[\x00-\x1f\x7f]/g, "").slice(0, MAX_TITLE_LENGTH);
+  return `\x1B]0;${safe}\x07`;
+}
+var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, REGISTERED_AGENTS, MAX_TITLE_LENGTH = 200;
+var init_agent_registry = __esm(() => {
+  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  PROFILES = {
+    omp: {
+      id: "omp",
+      displayName: "OMP",
+      title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
+      hostHookSource: "omp",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
+      quota: "gauge",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
+    },
+    pi: {
+      id: "pi",
+      displayName: "Pi",
+      title: { workingLabel: "Pi", permissionLabel: "Pi - action required", idleLabel: "Pi ready" },
+      hostHookSource: "pi",
+      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
+    },
+    codex: {
+      id: "codex",
+      displayName: "Codex",
+      title: {
+        workingLabel: "Codex",
+        permissionLabel: "Codex - action required",
+        idleLabel: "Codex ready",
+        synthesizeWorking: false
+      },
+      hostHookSource: "codex",
+      quota: "gauge",
+      approvalBypassArgs: ["--dangerously-bypass-approvals-and-sandbox"],
+      structuredApprovals: true,
+      resume: { argv: ["resume", "{ref}"], ref: "sessionId", form: "subcommand" }
+    },
+    opencode: {
+      id: "opencode",
+      displayName: "OpenCode",
+      title: {
+        workingLabel: "OpenCode",
+        permissionLabel: "OpenCode - action required",
+        idleLabel: "OpenCode ready",
+        synthesizeTerminal: false
+      },
+      hostHookSource: "opencode",
+      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
+    },
+    cursor: {
+      id: "cursor",
+      displayName: "Cursor Agent",
+      title: {
+        workingLabel: "Cursor Agent",
+        permissionLabel: "Cursor - action required",
+        idleLabel: "Cursor ready"
+      },
+      hostHookSource: "cursor",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
+    },
+    droid: {
+      id: "droid",
+      displayName: "Droid",
+      title: { workingLabel: "Droid", permissionLabel: "Droid - action required", idleLabel: "Droid ready" },
+      hostHookSource: "droid",
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
+    },
+    claude: {
+      id: "claude",
+      displayName: "Claude Code",
+      title: {
+        workingLabel: "Claude",
+        permissionLabel: "Claude - action required",
+        idleLabel: "Claude ready",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
+      hostHookSource: "claude",
+      quota: "event",
+      approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId", selfNamed: "uuid" }
+    },
+    gemini: {
+      id: "gemini",
+      displayName: "Gemini CLI",
+      title: {
+        workingLabel: "Gemini",
+        permissionLabel: "Gemini - action required",
+        idleLabel: "Gemini ready",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
+      hostHookSource: "gemini",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
+      hookAck: "{}",
+      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
+      resume: { argv: ["--resume", "{ref}"], ref: "sessionId", selfNamed: "bare" }
+    }
+  };
+  REGISTERED_AGENTS = Object.keys(PROFILES);
+});
+
+// packages/core/src/session-id.ts
+function uuidFromSessionId(sessionId) {
+  const hex = sessionId.replace(/-/g, "");
+  if (hex.length !== 32)
+    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function sessionIdFromUuid(ref) {
+  if (!ref.includes("-"))
+    return;
+  const stripped = ref.replace(/-/g, "");
+  return /^[0-9a-f]{4,32}$/i.test(stripped) ? stripped.toLowerCase() : undefined;
+}
+
 // packages/core/src/mcp-config.ts
 function mcpServerEntry(launch, contextPath) {
   return {
@@ -63,12 +224,6 @@ function codexMcpArgs(launch, contextPath) {
 var MCP_SERVER_NAME = "axterm", MCP_CONTEXT_ENV = "AXTERM_MCP_CONTEXT";
 
 // packages/core/src/agent-launch.ts
-function uuidFromSessionId(sessionId) {
-  const hex = sessionId.replace(/-/g, "");
-  if (hex.length !== 32)
-    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
 function withAppServer(argv, url) {
   const out = [];
   for (let i = 0;i < argv.length; i++) {
@@ -82,6 +237,15 @@ function withAppServer(argv, url) {
     return out;
   return [out[0], "--remote", url, ...out.slice(1)];
 }
+function resumesAConversation(args) {
+  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 ?? []];
   if (input.agent === "claude") {
@@ -90,16 +254,14 @@ function buildAgentCommand(input) {
       "--settings",
       input.claudeSettingsPath,
       ...input.mcpConfigPath === undefined ? [] : ["--mcp-config", input.mcpConfigPath],
-      "--session-id",
-      uuidFromSessionId(input.sessionId),
+      ...namingFlag("claude", input.sessionId, extra),
       ...extra
     ];
   }
   if (input.agent === "gemini") {
     return [
       "gemini",
-      "--session-id",
-      input.sessionId,
+      ...namingFlag("gemini", input.sessionId, extra),
       ...extra
     ];
   }
@@ -136,30 +298,16 @@ function resolveAgentArgs(input) {
   });
   return groups.filter((group, index) => group.flag === undefined || lastIndex.get(group.flag) === index).flatMap((group) => group.tokens);
 }
-function buildAgentResumeCommand(input) {
-  if (input.agent === "claude") {
-    return [
-      "claude",
-      "--settings",
-      input.claudeSettingsPath,
-      "--resume",
-      uuidFromSessionId(input.sessionId),
-      ...input.extraArgs ?? []
-    ];
-  }
-  if (input.agent === "gemini") {
-    return ["gemini", "--resume", input.sessionId, ...input.extraArgs ?? []];
-  }
-  return buildAgentCommand(input);
-}
 function isAgentId(value) {
   return AGENT_IDS.includes(value);
 }
 function supportedAgents() {
   return AGENT_IDS;
 }
-var AGENT_IDS;
+var RESUME_FLAGS, AGENT_IDS;
 var init_agent_launch = __esm(() => {
+  init_agent_registry();
+  RESUME_FLAGS = new Set(["--resume", "-r", "--continue", "-c"]);
   AGENT_IDS = ["omp", "claude", "codex", "gemini"];
 });
 
@@ -406,6 +554,9 @@ function isRecord(value) {
 }
 
 // packages/core/src/config-schema.ts
+function isStagingMode(value) {
+  return typeof value === "string" && STAGING_MODES.includes(value);
+}
 function resolveStreamConfig(file) {
   return {
     enabled: file?.enabled ?? DEFAULT_STREAM_CONFIG.enabled,
@@ -499,7 +650,7 @@ function parseConfig(raw) {
   }
   const defaults = raw["defaults"];
   if (isRecord(defaults)) {
-    checkKeys(defaults, ["agent", "shell", "autoApprove", "agentArgs"], "defaults.", errors);
+    checkKeys(defaults, ["agent", "shell", "autoApprove", "agentArgs", "staging"], "defaults.", errors);
     const agent = defaults["agent"];
     const shell = defaults["shell"];
     const rawArgs = defaults["agentArgs"];
@@ -518,11 +669,16 @@ function parseConfig(raw) {
     if (autoApprove !== undefined && typeof autoApprove !== "boolean") {
       errors.push("defaults.autoApprove must be true or false");
     }
+    const staging = defaults["staging"];
+    if (staging !== undefined && !isStagingMode(staging)) {
+      errors.push(`defaults.staging must be one of: ${STAGING_MODES.join(", ")}`);
+    }
     config.defaults = {
       ...typeof agent === "string" ? { agent } : {},
       ...typeof shell === "string" ? { shell } : {},
       ...typeof autoApprove === "boolean" ? { autoApprove } : {},
-      ...Object.keys(agentArgs).length > 0 ? { agentArgs } : {}
+      ...Object.keys(agentArgs).length > 0 ? { agentArgs } : {},
+      ...isStagingMode(staging) ? { staging } : {}
     };
   }
   const projects = raw["projects"];
@@ -631,6 +787,9 @@ function setConfigValue(config, dottedPath, rawValue) {
     const shown = Array.isArray(rawValue) ? rawValue.join(" ") : rawValue;
     return { error: `"${shown}" is not a valid ${type} for ${dottedPath}` };
   }
+  if (dottedPath === "defaults.staging" && !isStagingMode(value)) {
+    return { error: `"${String(value)}" is not a valid location \u2014 use one of: ${STAGING_MODES.join(", ")}` };
+  }
   const next = structuredClone(config);
   const segments = dottedPath.split(".");
   let cursor = next;
@@ -674,10 +833,11 @@ function resolveEnvRefs(config, env) {
   }
   return resolved;
 }
-var CONFIG_VERSION = 1, DEFAULT_CONFIG, DEFAULT_STREAM_CONFIG, DEFAULT_INBOUND_CONFIG, FIELDS, SECRET_SUFFIXES, ENV_REF;
+var STAGING_MODES, CONFIG_VERSION = 1, DEFAULT_CONFIG, DEFAULT_STREAM_CONFIG, DEFAULT_INBOUND_CONFIG, FIELDS, SECRET_SUFFIXES, ENV_REF;
 var init_config_schema = __esm(() => {
   init_agent_launch();
   init_channel_spi();
+  STAGING_MODES = ["project", "runtime"];
   DEFAULT_CONFIG = {
     version: CONFIG_VERSION,
     projects: [],
@@ -703,6 +863,7 @@ var init_config_schema = __esm(() => {
     "defaults.agent": "string",
     "defaults.shell": "string",
     "defaults.autoApprove": "boolean",
+    "defaults.staging": "string",
     "channels.telegram.enabled": "boolean",
     "channels.telegram.groupId": "number",
     "channels.telegram.allowUserIds": "number[]",
@@ -768,6 +929,7 @@ function resolvePaths(input) {
     extDir: join(stateDir, "ext"),
     runtimeFile: join(runtimeDir, "runtime.json"),
     hookEndpointFile: join(runtimeDir, "hook-endpoint.env"),
+    ptyHostFile: join(runtimeDir, "pty-host.json"),
     legacyRoots: legacyRoots.filter((dir) => dir !== stateDir)
   };
 }
@@ -876,6 +1038,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.session.sent": "sent",
     "cli.session.sentKey": "sent {key}",
     "cli.session.selected": "selected option {index}",
+    "cli.session.selectedDialog": "answered the agent's first-run dialog",
     "cli.resume.done": "resumed session {id} ({command})",
     "cli.update.current": "axterm {version} is the latest version",
     "cli.update.available": "axterm {latest} is available (you have {current})",
@@ -945,7 +1108,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "err.telegram.noToken": "no bot token is configured \u2014 run `axterm setup` or pass --token",
     "tg.help.general.header": "axterm commands (General topic):",
     "tg.help.general.projects": "/projects \u2014 registered projects",
-    "tg.help.general.new": "/new <project> [name] \u2014 new omp session",
+    "tg.help.general.new": "/new <project> [name] [-- agent flags] \u2014 new session (e.g. --resume <conversation>)",
     "tg.help.general.wt": "/wt <project> <branch> \u2014 worktree session",
     "tg.help.general.fanout": "/fanout <project> <count|branches> <prompt> \u2014 run in parallel",
     "tg.help.general.worktrees": "/worktrees <project> \xB7 /rm <project> <branch> [force]",
@@ -967,6 +1130,9 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.prompt.confirm": "the session is waiting on a confirmation:",
     "tg.prompt.secretAsk": "the session is asking for a secret. Reply with it and the message will be deleted:",
     "tg.prompt.secretDisabled": "the session is waiting for a password. Answering from chat is off (channels.telegram.secretPrompts); attach and type it, or use an SSH key",
+    "tg.prompt.secretSubmitted": "the secret reached the session",
+    "tg.prompt.secretStale": "that prompt is no longer waiting, so nothing was typed into the session",
+    "tg.prompt.secretUndeleted": "\u26A0\uFE0F Telegram refused to delete that message \u2014 the secret is still in the chat; delete it yourself",
     "tg.session.screenFile": "terminal screen",
     "tg.session.none": "no sessions",
     "tg.prompt.failed": "\u26A0\uFE0F Delivery failed: {error}",
@@ -1044,6 +1210,8 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.bridge.missing": "hook bridge: {command} does not exist \u2014 codex and gemini hooks would fail once per tool call",
     "doctor.agent.installed": "{agent}: installed ({path})",
     "doctor.agent.notInstalled": "{agent}: not installed",
+    "doctor.staging.project": "inbound files: written to <session dir>/.axterm/inbound (hidden from git; set defaults.staging=runtime for a synced folder)",
+    "doctor.staging.runtime": "inbound files: written to axterm's own runtime directory (defaults.staging=runtime)",
     "doctor.omp.extensionOk": "omp extension: deployed ({path})",
     "doctor.omp.extensionMissing": "omp extension: missing at {path} \u2014 no omp session can report status",
     "doctor.gemini.settingsOk": "gemini hooks: defaults file valid ({events} events subscribed)",
@@ -1082,6 +1250,10 @@ 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.staging.dir": "could not create the session's staging directory {dir} ({error}) \u2014 fix the permissions, or set defaults.staging to runtime",
+    "err.staging.notIgnored": "git can see inside {dir}, so a staged file would show up in `git add -A` \u2014 let axterm write its own {file}, or set defaults.staging to runtime",
+    "err.claude.conversationBusy": "session {session} is already in conversation {id} \u2014 two sessions writing one transcript would corrupt it; kill that one first",
+    "err.claude.noConversation": "claude has no conversation {id} in its store on this machine \u2014 a conversation lives on the machine it ran on, so this one cannot be resumed here",
     "codex.approval.denied": "Denied from the axterm channel",
     "err.codex.noAuth": "codex is not logged in ({authFile} not found) \u2014 run `codex login` once, then start the session again",
     "err.codex.authLink": "could not link codex credentials into axterm's CODEX_HOME ({reason}) \u2014 refusing to start a logged-out agent",
@@ -1172,6 +1344,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.session.sent": "\uC804\uB2EC\uB428",
     "cli.session.sentKey": "{key} \uC804\uB2EC\uB428",
     "cli.session.selected": "{index}\uBC88 \uD56D\uBAA9 \uC120\uD0DD\uB428",
+    "cli.session.selectedDialog": "\uC5D0\uC774\uC804\uD2B8\uC758 \uCCAB \uC2E4\uD589 \uB300\uD654\uC0C1\uC790\uC5D0 \uC751\uB2F5\uD588\uC2B5\uB2C8\uB2E4",
     "cli.resume.done": "\uC138\uC158 {id} \uC7AC\uAC1C\uB428 ({command})",
     "cli.update.current": "axterm {version} \uC774 \uCD5C\uC2E0 \uBC84\uC804\uC785\uB2C8\uB2E4",
     "cli.update.available": "axterm {latest} \uC744(\uB97C) \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4 (\uD604\uC7AC {current})",
@@ -1234,7 +1407,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.telegram.missingSettings": "telegram link: \uD1A0\uD070/\uADF8\uB8F9/\uC0AC\uC6A9\uC790 \uC815\uBCF4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. --token/--group/--user \uD50C\uB798\uADF8, TELEGRAM_* \uD658\uACBD\uBCC0\uC218, \uB610\uB294 \uD604\uC7AC \uD3F4\uB354\uC758 .env \uD30C\uC77C \uC911 \uD558\uB098\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.",
     "tg.help.general.header": "axterm \uBA85\uB839 (General \uD1A0\uD53D):",
     "tg.help.general.projects": "/projects \u2014 \uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8",
-    "tg.help.general.new": "/new <\uD504\uB85C\uC81D\uD2B8> [\uC774\uB984] \u2014 \uC0C8 omp \uC138\uC158",
+    "tg.help.general.new": "/new <\uD504\uB85C\uC81D\uD2B8> [\uC774\uB984] [\uC5D0\uC774\uC804\uD2B8 \uD50C\uB798\uADF8] \u2014 \uC0C8 \uC138\uC158 (\uC608: --resume <\uB300\uD654>)",
     "tg.help.general.wt": "/wt <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> \u2014 worktree \uC138\uC158",
     "tg.help.general.fanout": "/fanout <\uD504\uB85C\uC81D\uD2B8> <\uAC1C\uC218|\uBE0C\uB79C\uCE58\uB4E4> <\uD504\uB86C\uD504\uD2B8> \u2014 \uBCD1\uB82C \uC2E4\uD589",
     "tg.help.general.worktrees": "/worktrees <\uD504\uB85C\uC81D\uD2B8> \xB7 /rm <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> [force]",
@@ -1263,6 +1436,9 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.prompt.confirm": "\uC138\uC158\uC774 \uD655\uC778\uC744 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4:",
     "tg.prompt.secretAsk": "\uC138\uC158\uC774 \uBE44\uBC00\uAC12\uC744 \uC694\uAD6C\uD569\uB2C8\uB2E4. \uB2F5\uC7A5\uD558\uBA74 \uADF8 \uBA54\uC2DC\uC9C0\uB294 \uC0AD\uC81C\uB429\uB2C8\uB2E4:",
     "tg.prompt.secretDisabled": "\uC138\uC158\uC774 \uBE44\uBC00\uBC88\uD638\uB97C \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4. \uCC44\uD305 \uC785\uB825\uC740 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4 (channels.telegram.secretPrompts). attach \uD574\uC11C \uC785\uB825\uD558\uAC70\uB098 SSH \uD0A4\uB97C \uC4F0\uC138\uC694",
+    "tg.prompt.secretSubmitted": "\uBE44\uBC00\uAC12\uC774 \uC138\uC158\uC5D0 \uC804\uB2EC\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+    "tg.prompt.secretStale": "\uADF8 \uD504\uB86C\uD504\uD2B8\uB294 \uB354 \uC774\uC0C1 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC9C0 \uC54A\uC544 \uC138\uC158\uC5D0 \uC544\uBB34\uAC83\uB3C4 \uC785\uB825\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4",
+    "tg.prompt.secretUndeleted": "\u26A0\uFE0F Telegram\uC774 \uBA54\uC2DC\uC9C0 \uC0AD\uC81C\uB97C \uAC70\uBD80\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uBE44\uBC00\uAC12\uC774 \uC544\uC9C1 \uCC44\uD305\uC5D0 \uB0A8\uC544 \uC788\uC2B5\uB2C8\uB2E4. \uC9C1\uC811 \uC0AD\uC81C\uD558\uC138\uC694",
     "tg.session.screenFile": "\uD130\uBBF8\uB110 \uD654\uBA74",
     "tg.session.none": "\uC138\uC158 \uC5C6\uC74C",
     "tg.prompt.failed": "\u26A0\uFE0F \uC804\uB2EC \uC2E4\uD328: {error}",
@@ -1340,6 +1516,8 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.bridge.missing": "\uD6C5 \uBE0C\uB9AC\uC9C0: {command} \uC5C6\uC74C \u2014 codex\xB7gemini \uD6C5\uC774 \uD234 \uD638\uCD9C\uB9C8\uB2E4 \uC2E4\uD328\uD558\uAC8C \uB429\uB2C8\uB2E4",
     "doctor.agent.installed": "{agent}: \uC124\uCE58\uB428 ({path})",
     "doctor.agent.notInstalled": "{agent}: \uBBF8\uC124\uCE58",
+    "doctor.staging.project": "\uC778\uBC14\uC6B4\uB4DC \uD30C\uC77C: <\uC138\uC158 \uB514\uB809\uD130\uB9AC>/.axterm/inbound \uC5D0 \uC501\uB2C8\uB2E4 (git\uC5D0\uC11C \uAC10\uCDB0\uC9D0; \uB3D9\uAE30\uD654 \uD3F4\uB354\uB77C\uBA74 defaults.staging=runtime)",
+    "doctor.staging.runtime": "\uC778\uBC14\uC6B4\uB4DC \uD30C\uC77C: axterm \uC790\uCCB4 \uB7F0\uD0C0\uC784 \uB514\uB809\uD130\uB9AC\uC5D0 \uC501\uB2C8\uB2E4 (defaults.staging=runtime)",
     "doctor.omp.extensionOk": "omp \uD655\uC7A5: \uBC30\uD3EC\uB428 ({path})",
     "doctor.omp.extensionMissing": "omp \uD655\uC7A5: {path} \uC5C6\uC74C \u2014 \uC5B4\uB5A4 omp \uC138\uC158\uB3C4 \uC0C1\uD0DC\uB97C \uBCF4\uACE0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
     "doctor.gemini.settingsOk": "gemini \uD6C5: defaults \uD30C\uC77C \uC815\uC0C1 ({events}\uAC1C \uC774\uBCA4\uD2B8 \uAD6C\uB3C5)",
@@ -1378,6 +1556,10 @@ 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.staging.dir": "\uC138\uC158\uC758 \uC2A4\uD14C\uC774\uC9D5 \uB514\uB809\uD130\uB9AC {dir} \uC744(\uB97C) \uB9CC\uB4E4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 ({error}). \uAD8C\uD55C\uC744 \uACE0\uCE58\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
+    "err.staging.notIgnored": "git\uC774 {dir} \uC548\uC744 \uBCFC \uC218 \uC788\uC5B4\uC11C, \uC2A4\uD14C\uC774\uC9D5\uD55C \uD30C\uC77C\uC774 `git add -A` \uC5D0 \uC7A1\uD799\uB2C8\uB2E4. axterm\uC774 \uC790\uCCB4 {file} \uC744(\uB97C) \uC4F0\uAC8C \uD558\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
+    "err.claude.conversationBusy": "\uC138\uC158 {session} \uC774(\uAC00) \uC774\uBBF8 \uB300\uD654 {id} \uC5D0 \uB4E4\uC5B4\uAC00 \uC788\uC2B5\uB2C8\uB2E4. \uD55C transcript\uC5D0 \uB450 \uC138\uC158\uC774 \uC4F0\uBA74 \uC190\uC0C1\uB418\uBBC0\uB85C \uBA3C\uC800 \uADF8 \uC138\uC158\uC744 \uC885\uB8CC\uD558\uC138\uC694",
+    "err.claude.noConversation": "\uC774 \uBA38\uC2E0\uC758 claude \uC800\uC7A5\uC18C\uC5D0 \uB300\uD654 {id} \uC774(\uAC00) \uC5C6\uC2B5\uB2C8\uB2E4. \uB300\uD654\uB294 \uC2E4\uD589\uB41C \uBA38\uC2E0\uC5D0 \uB0A8\uC73C\uBBC0\uB85C \uC5EC\uAE30\uC11C\uB294 \uC774\uC5B4\uAC08 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
     "codex.approval.denied": "axterm \uCC44\uB110\uC5D0\uC11C \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
     "err.codex.noAuth": "codex\uC5D0 \uB85C\uADF8\uC778\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 ({authFile} \uC5C6\uC74C). `codex login` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD55C \uB4A4 \uC138\uC158\uC744 \uB2E4\uC2DC \uC2DC\uC791\uD558\uC138\uC694",
     "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",
@@ -1567,144 +1749,16 @@ var init_setup_wizard = __esm(() => {
   wizardConfig = new WeakMap;
 });
 
-// packages/core/src/agent-registry.ts
-function agentProfile(id) {
-  const known = PROFILES[id];
-  if (known)
-    return known;
-  return {
-    id,
-    displayName: id,
-    title: {
-      workingLabel: id,
-      permissionLabel: `${id} - action required`,
-      idleLabel: `${id} ready`
-    },
-    hostHookSource: id
-  };
-}
-function renderAgentTitle(profile, state, frame) {
-  if (state === undefined)
-    return;
-  const { title } = profile;
-  if (state === "working") {
-    if (title.synthesizeWorking === false)
-      return;
-    const spinner = SPINNER_FRAMES[(frame % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length];
-    return `${spinner} ${title.workingLabel}`;
-  }
-  if (title.synthesizeTerminal === false)
-    return;
-  return state === "done" ? title.idleLabel : title.permissionLabel;
-}
-function oscTitle(title) {
-  const safe = title.replace(/[\x00-\x1f\x7f]/g, "").slice(0, MAX_TITLE_LENGTH);
-  return `\x1B]0;${safe}\x07`;
-}
-var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, REGISTERED_AGENTS, MAX_TITLE_LENGTH = 200;
-var init_agent_registry = __esm(() => {
-  SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  PROFILES = {
-    omp: {
-      id: "omp",
-      displayName: "OMP",
-      title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
-      hostHookSource: "omp",
-      approvalBypassArgs: ["--approval-mode", "yolo"],
-      quota: "gauge",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
-    },
-    pi: {
-      id: "pi",
-      displayName: "Pi",
-      title: { workingLabel: "Pi", permissionLabel: "Pi - action required", idleLabel: "Pi ready" },
-      hostHookSource: "pi",
-      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
-    },
-    codex: {
-      id: "codex",
-      displayName: "Codex",
-      title: {
-        workingLabel: "Codex",
-        permissionLabel: "Codex - action required",
-        idleLabel: "Codex ready",
-        synthesizeWorking: false
-      },
-      hostHookSource: "codex",
-      quota: "gauge",
-      approvalBypassArgs: ["--dangerously-bypass-approvals-and-sandbox"],
-      structuredApprovals: true,
-      resume: { argv: ["resume", "{ref}"], ref: "sessionId", form: "subcommand" }
-    },
-    opencode: {
-      id: "opencode",
-      displayName: "OpenCode",
-      title: {
-        workingLabel: "OpenCode",
-        permissionLabel: "OpenCode - action required",
-        idleLabel: "OpenCode ready",
-        synthesizeTerminal: false
-      },
-      hostHookSource: "opencode",
-      resume: { argv: ["--session", "{ref}"], ref: "sessionId" }
-    },
-    cursor: {
-      id: "cursor",
-      displayName: "Cursor Agent",
-      title: {
-        workingLabel: "Cursor Agent",
-        permissionLabel: "Cursor - action required",
-        idleLabel: "Cursor ready"
-      },
-      hostHookSource: "cursor",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    droid: {
-      id: "droid",
-      displayName: "Droid",
-      title: { workingLabel: "Droid", permissionLabel: "Droid - action required", idleLabel: "Droid ready" },
-      hostHookSource: "droid",
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    claude: {
-      id: "claude",
-      displayName: "Claude Code",
-      title: {
-        workingLabel: "Claude",
-        permissionLabel: "Claude - action required",
-        idleLabel: "Claude ready",
-        synthesizeWorking: false,
-        synthesizeTerminal: false
-      },
-      hostHookSource: "claude",
-      quota: "event",
-      approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    },
-    gemini: {
-      id: "gemini",
-      displayName: "Gemini CLI",
-      title: {
-        workingLabel: "Gemini",
-        permissionLabel: "Gemini - action required",
-        idleLabel: "Gemini ready",
-        synthesizeWorking: false,
-        synthesizeTerminal: false
-      },
-      hostHookSource: "gemini",
-      approvalBypassArgs: ["--approval-mode", "yolo"],
-      hookAck: "{}",
-      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
-      resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
-    }
-  };
-  REGISTERED_AGENTS = Object.keys(PROFILES);
-});
-
 // packages/core/src/agent-resume.ts
 function resumeReference(profile, source) {
-  const value = profile.resume?.ref === "sessionId" ? source.agentSessionId : source.agentSessionFile;
-  return value !== undefined && value.length > 0 ? value : undefined;
+  const reported = profile.resume?.ref === "sessionId" ? source.agentSessionId : source.agentSessionFile;
+  if (reported !== undefined && reported.length > 0)
+    return reported;
+  const named = profile.resume?.selfNamed;
+  const own = source.ownSessionId;
+  if (named === undefined || own === undefined || own.length === 0)
+    return;
+  return named === "uuid" ? uuidFromSessionId(own) : own;
 }
 function agentIdFromCommand(command) {
   const head = command[0] ?? "";
@@ -1731,17 +1785,23 @@ function withoutExistingResume(command, fragment) {
   }
   return command;
 }
+function withoutNamingFlag(command) {
+  const at = command.indexOf("--session-id");
+  return at < 0 ? command : [...command.slice(0, at), ...command.slice(at + 2)];
+}
 function buildResumeCommand(command, profile, reference) {
   const resume = profile.resume;
   const binary = command[0];
   if (!resume || binary === undefined || reference.length === 0)
     return;
   const template = resume.argv;
-  const base = withoutExistingResume(command, template);
+  const stripped = withoutExistingResume(command, template);
+  const base = resume.selfNamed === undefined ? stripped : withoutNamingFlag(stripped);
   const fragment = template.map((token) => token.replaceAll(REF, reference));
   return resume.form === "subcommand" ? [base[0], ...fragment, ...base.slice(1)] : [...base, ...fragment];
 }
 var REF = "{ref}";
+var init_agent_resume = () => {};
 
 // packages/core/src/self-spawn.ts
 function daemonLaunch(input) {
@@ -1763,9 +1823,16 @@ function mcpLaunch(input) {
 function isMcpInvocation(args) {
   return args[0] === MCP_ARGV_FLAG;
 }
-function hookPostTarget(env, agent) {
-  const port = Number(env["AXTERM_HOOK_PORT"]);
-  const token = env["AXTERM_HOOK_TOKEN"];
+function ptyHostLaunch(input) {
+  const base = daemonLaunch(input);
+  return { command: base.command, args: [...base.args.slice(0, -1), PTY_HOST_ARGV_FLAG] };
+}
+function isPtyHostInvocation(args) {
+  return args[0] === PTY_HOST_ARGV_FLAG;
+}
+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)
@@ -1782,10 +1849,17 @@ 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;
 }
-var DAEMON_ARGV_FLAG = "__daemon", HOOK_ARGV_FLAG = "__hook", MCP_ARGV_FLAG = "__mcp", RUNTIME_NAMES;
+var DAEMON_ARGV_FLAG = "__daemon", HOOK_ARGV_FLAG = "__hook", MCP_ARGV_FLAG = "__mcp", PTY_HOST_ARGV_FLAG = "__pty-host", RUNTIME_NAMES;
 var init_self_spawn = __esm(() => {
   RUNTIME_NAMES = new Set(["bun", "bun.exe", "bun-debug", "bun-debug.exe", "node", "node.exe"]);
 });
@@ -1907,6 +1981,7 @@ function planUpdateRestart(input) {
 var SEMVER;
 var init_update = __esm(() => {
   init_agent_registry();
+  init_agent_resume();
   SEMVER = /^\d+\.\d+\.\d+/;
 });
 
@@ -2107,6 +2182,30 @@ function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
 }
 var MENU_UP = "\x1B[A", MENU_DOWN = "\x1B[B", MENU_SELECT = "\r", MENU_NORMALIZE_PRESSES = 24;
 
+// packages/core/src/adopt.ts
+function resolveSessionCwd(input) {
+  if (!input.preferConversation)
+    return input.requested;
+  const own = input.conversationCwd;
+  return own !== undefined && own.length > 0 ? own : input.requested;
+}
+function conversationHeldBy(sessions, conversationId) {
+  if (conversationId.length === 0)
+    return;
+  return sessions.find((session) => {
+    if (session.state !== "running")
+      return false;
+    if (session.agentSessionId === conversationId)
+      return true;
+    const argv = session.agentCommand;
+    return argv.some((token, index) => {
+      if (token === "--resume" || token === "-r" || token === "--session-id")
+        return argv[index + 1] === conversationId;
+      return token === `--resume=${conversationId}`;
+    });
+  });
+}
+
 // packages/core/src/agent-status.ts
 function next(prev, state, now) {
   return {
@@ -2116,17 +2215,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 ?? "";
@@ -2218,7 +2329,102 @@ var init_agent_status = __esm(() => {
   ]);
 });
 
+// packages/core/src/pty-protocol.ts
+function encodeFrame(kind, id, payload) {
+  const idBytes = new TextEncoder().encode(id);
+  if (idBytes.length > 255)
+    throw new Error(`session id too long for a frame header: ${idBytes.length} bytes`);
+  const frame = new Uint8Array(HEADER_BYTES + idBytes.length + payload.byteLength);
+  frame[0] = kind;
+  frame[1] = idBytes.length;
+  new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(2, payload.byteLength, true);
+  frame.set(idBytes, HEADER_BYTES);
+  frame.set(payload, HEADER_BYTES + idBytes.length);
+  return frame;
+}
+function isFrameKind(value) {
+  return value === FrameKind.Control || value === FrameKind.Data;
+}
+
+class FrameDecoder {
+  buffer = new Uint8Array(0);
+  push(chunk) {
+    this.buffer = concat(this.buffer, chunk);
+    const frames = [];
+    for (;; ) {
+      if (this.buffer.byteLength < HEADER_BYTES)
+        return frames;
+      const kind = this.buffer[0];
+      if (!isFrameKind(kind))
+        throw new Error(`unknown frame kind ${kind}`);
+      const idLength = this.buffer[1];
+      const payloadLength = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength).getUint32(2, true);
+      if (payloadLength > MAX_FRAME_BYTES) {
+        throw new Error(`frame too large: ${payloadLength} bytes declared, ceiling is ${MAX_FRAME_BYTES}`);
+      }
+      const total = HEADER_BYTES + idLength + payloadLength;
+      if (this.buffer.byteLength < total)
+        return frames;
+      const id = new TextDecoder().decode(this.buffer.subarray(HEADER_BYTES, HEADER_BYTES + idLength));
+      const payload = this.buffer.slice(HEADER_BYTES + idLength, total);
+      frames.push({ kind, id, payload });
+      this.buffer = this.buffer.slice(total);
+    }
+  }
+}
+function concat(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  const joined = new Uint8Array(left.byteLength + right.byteLength);
+  joined.set(left, 0);
+  joined.set(right, left.byteLength);
+  return joined;
+}
+function parseControl(payload) {
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(payload));
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return;
+  const type = parsed.t;
+  if (typeof type !== "string" || !KNOWN_TYPES.has(type))
+    return;
+  return parsed;
+}
+function controlFrame(message) {
+  return encodeFrame(FrameKind.Control, "", new TextEncoder().encode(JSON.stringify(message)));
+}
+var PTY_PROTOCOL_VERSION = 1, FrameKind, MAX_FRAME_BYTES, HEADER_BYTES = 6, KNOWN_TYPES;
+var init_pty_protocol = __esm(() => {
+  FrameKind = {
+    Control: 1,
+    Data: 2
+  };
+  MAX_FRAME_BYTES = 8 * 1024 * 1024;
+  KNOWN_TYPES = new Set([
+    "hello",
+    "spawn",
+    "subscribe",
+    "resize",
+    "kill",
+    "welcome",
+    "spawned",
+    "subscribed",
+    "exit",
+    "error"
+  ]);
+});
+
 // packages/core/src/workspace.ts
+function scratchDir(sessionDir) {
+  return `${sessionDir.replace(/[/\\]+$/, "")}/${SCRATCH_DIR_NAME}`;
+}
+function inboundStagingDir(sessionDir) {
+  return `${scratchDir(sessionDir)}/inbound`;
+}
 function planMaterialisedPath(stagingDir, sessionId, remotePath) {
   const parts = remotePath.split(/[/\\]/);
   let base = "";
@@ -2239,7 +2445,8 @@ function planMaterialisedPath(stagingDir, sessionId, remotePath) {
   }
   return `${stagingDir}/${sessionId}/${name}`;
 }
-var MAX_NAME = 120;
+var SCRATCH_DIR_NAME = ".axterm", SCRATCH_IGNORE_NAME = ".gitignore", SCRATCH_IGNORE_BODY = `*
+`, MAX_NAME = 120;
 
 // packages/core/src/claude-hooks.ts
 function resultText(response) {
@@ -2403,6 +2610,8 @@ var init_onboarding = __esm(() => {
       { kind: "authMethod", question: "How would you like to authenticate for this project?" }
     ],
     claude: [
+      { kind: "folderTrust", question: "Quick safety check: Is this a project you created or one you trust?" },
+      { kind: "autoMode", question: "Set up auto mode for your environment?" },
       { kind: "apiKey", question: "Do you want to use this API key?" },
       { kind: "loginMethod", question: "Select login method:" }
     ],
@@ -2430,6 +2639,15 @@ function evaluateVersionDrift(input) {
     }
   ];
 }
+function evaluateStagingDoctor(facts) {
+  return [
+    {
+      id: "staging.mode",
+      status: "info",
+      key: facts.mode === "runtime" ? "doctor.staging.runtime" : "doctor.staging.project"
+    }
+  ];
+}
 function binaryCheck(agent, binary) {
   return binary === undefined ? { id: `${agent}.binary`, status: "info", key: "doctor.agent.notInstalled", params: { agent } } : { id: `${agent}.binary`, status: "ok", key: "doctor.agent.installed", params: { agent, path: binary } };
 }
@@ -3435,6 +3653,9 @@ function sessionsByRecency(live, stored) {
 var asGiven = (target) => target;
 var init_session_scope = () => {};
 
+// packages/core/src/test-scratch.ts
+var init_test_scratch = () => {};
+
 // packages/core/src/index.ts
 function isRpcEvent(f) {
   return typeof f.ev === "string";
@@ -3454,6 +3675,7 @@ var init_src = __esm(() => {
   init_config_paths();
   init_setup_wizard();
   init_agent_registry();
+  init_agent_resume();
   init_self_spawn();
   init_channel_spi();
   init_update();
@@ -3463,6 +3685,7 @@ var init_src = __esm(() => {
   init_choice();
   init_agent_status();
   init_activity();
+  init_pty_protocol();
   init_claude_hooks();
   init_onboarding();
   init_doctor();
@@ -3480,19 +3703,20 @@ var init_src = __esm(() => {
   init_dotenv_scrub();
   init_prompt_detect();
   init_session_scope();
+  init_test_scratch();
   SUBMIT_DELAY_MS = process.platform === "win32" ? 1500 : 500;
   PASTE_CHUNK_BYTES = 16 * 1024;
 });
 
 // packages/daemon/src/config-store.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path6 from "path";
 function writeAtomic(target, contents, mode) {
   const tmp = `${target}.tmp`;
-  fs5.writeFileSync(tmp, contents, { mode });
-  fs5.renameSync(tmp, target);
+  fs6.writeFileSync(tmp, contents, { mode });
+  fs6.renameSync(tmp, target);
   if (process.platform !== "win32")
-    fs5.chmodSync(target, mode);
+    fs6.chmodSync(target, mode);
 }
 
 class ConfigStore {
@@ -3508,16 +3732,16 @@ class ConfigStore {
   }
   load() {
     this.loadError = undefined;
-    fs5.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
+    fs6.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
     if (process.platform !== "win32") {
       try {
-        fs5.chmodSync(this.paths.configDir, DIR_MODE);
+        fs6.chmodSync(this.paths.configDir, DIR_MODE);
       } catch {}
     }
     this.config = structuredClone(DEFAULT_CONFIG);
-    if (fs5.existsSync(this.paths.configFile)) {
+    if (fs6.existsSync(this.paths.configFile)) {
       try {
-        const parsed = parseConfig(JSON.parse(fs5.readFileSync(this.paths.configFile, "utf8")));
+        const parsed = parseConfig(JSON.parse(fs6.readFileSync(this.paths.configFile, "utf8")));
         if ("errors" in parsed)
           this.loadError = parsed.errors.join("; ");
         else
@@ -3527,10 +3751,10 @@ class ConfigStore {
       }
     }
     this.secrets = {};
-    if (fs5.existsSync(this.paths.secretsFile)) {
+    if (fs6.existsSync(this.paths.secretsFile)) {
       this.tightenPermissions(this.paths.secretsFile);
       try {
-        const raw = JSON.parse(fs5.readFileSync(this.paths.secretsFile, "utf8"));
+        const raw = JSON.parse(fs6.readFileSync(this.paths.secretsFile, "utf8"));
         if (raw !== null && typeof raw === "object") {
           for (const [key, value] of Object.entries(raw)) {
             if (typeof value === "string")
@@ -3546,8 +3770,8 @@ class ConfigStore {
     if (process.platform === "win32")
       return;
     try {
-      if ((fs5.statSync(file).mode & 63) !== 0)
-        fs5.chmodSync(file, FILE_MODE);
+      if ((fs6.statSync(file).mode & 63) !== 0)
+        fs6.chmodSync(file, FILE_MODE);
     } catch {}
   }
   get() {
@@ -3555,7 +3779,7 @@ class ConfigStore {
   }
   health() {
     return configHealth({
-      fileExists: fs5.existsSync(this.paths.configFile),
+      fileExists: fs6.existsSync(this.paths.configFile),
       parseError: this.loadError,
       config: this.resolved()
     });
@@ -3600,7 +3824,7 @@ class ConfigStore {
       delete this.secrets[dottedPath];
     else
       this.secrets[dottedPath] = value;
-    if (!fs5.existsSync(this.paths.configFile)) {
+    if (!fs6.existsSync(this.paths.configFile)) {
       writeAtomic(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
 `, FILE_MODE);
     }
@@ -3630,7 +3854,7 @@ class ConfigStore {
   fingerprint() {
     const stamp = (file) => {
       try {
-        return String(fs5.statSync(file).mtimeMs);
+        return String(fs6.statSync(file).mtimeMs);
       } catch {
         return "-";
       }
@@ -3672,7 +3896,7 @@ var init_config_store = __esm(() => {
 });
 
 // packages/daemon/src/shell.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 function findExecutable(name, env) {
   const isWindows = env.platform === "win32";
@@ -3696,7 +3920,7 @@ function lookupOnPath(name) {
     platform: process.platform,
     pathEnv: process.env["PATH"] ?? "",
     pathExt: process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD",
-    exists: (candidate) => fs6.existsSync(candidate)
+    exists: (candidate) => fs7.existsSync(candidate)
   });
 }
 function resolveShell(kind) {
@@ -3733,7 +3957,7 @@ function resolvePosixShell(kind) {
       candidates.push({ kind: "bash", exe: login });
     candidates.push({ kind: "bash", exe: "/bin/bash" }, { kind: "bash", exe: "/usr/bin/bash" });
   }
-  const found = candidates.find((c) => fs6.existsSync(c.exe));
+  const found = candidates.find((c) => fs7.existsSync(c.exe));
   if (found)
     return found;
   return { kind: "sh", exe: "/bin/sh" };
@@ -3784,18 +4008,18 @@ var cachedPwsh;
 var init_shell = () => {};
 
 // packages/daemon/src/paths.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import os3 from "os";
 import path8 from "path";
 function ensureDataDirs() {
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir, SCROLLBACK_DIR, LOG_DIR, EXT_DIR]) {
-    fs7.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
+    fs8.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
   }
   if (process.platform === "win32")
     return;
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir]) {
     try {
-      fs7.chmodSync(dir, DIR_MODE2);
+      fs8.chmodSync(dir, DIR_MODE2);
     } catch {}
   }
 }
@@ -3803,14 +4027,14 @@ function restrictFile(file) {
   if (process.platform === "win32")
     return;
   try {
-    fs7.chmodSync(file, 384);
+    fs8.chmodSync(file, 384);
   } catch {}
 }
 function log(message) {
   const line = `${new Date().toISOString()} ${message}
 `;
   try {
-    fs7.appendFileSync(LOG_FILE, line);
+    fs8.appendFileSync(LOG_FILE, line);
   } catch {}
 }
 var PATHS, CONFIG_DIR, STATE_DIR, RUNTIME_DIR, SCROLLBACK_DIR, LOG_DIR, EXT_DIR, DB_PATH, RUNTIME_FILE2, HOOK_ENDPOINT_FILE, DIR_MODE2 = 448, PIPE_PATH, LOG_FILE;
@@ -3834,7 +4058,7 @@ var init_paths = __esm(() => {
 });
 
 // packages/daemon/src/store.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 import { Database } from "bun:sqlite";
 function rowToInfo(row) {
@@ -3866,7 +4090,7 @@ function rowToInfo(row) {
 class Store {
   db;
   constructor(dbPath = DB_PATH) {
-    fs8.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    fs9.mkdirSync(path9.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath, { strict: true });
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`
@@ -3945,8 +4169,10 @@ class Store {
     this.db.prepare(`UPDATE sessions SET state = 'running', exit_code = NULL, exited_at = NULL,
                              agent_command = ?, pty_pid = ? WHERE id = ?`).run(JSON.stringify(agentCommand), ptyPid ?? null, id);
   }
-  markStaleRunningAsExited() {
-    return this.db.prepare(`UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited'`).run(Date.now()).changes;
+  markStaleRunningAsExited(keep = []) {
+    const holes = keep.map(() => "?").join(",");
+    const sql = keep.length === 0 ? `UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited'` : `UPDATE sessions SET state = 'exited', exited_at = ? WHERE state != 'exited' AND id NOT IN (${holes})`;
+    return this.db.prepare(sql).run(Date.now(), ...keep).changes;
   }
   listSessions() {
     const rows = this.db.prepare(`SELECT * FROM sessions ORDER BY created_at DESC`).all();
@@ -3961,7 +4187,11 @@ class Store {
     return existed;
   }
   findByPrefix(idOrPrefix) {
-    const rows = this.db.prepare(`SELECT * FROM sessions WHERE id = ? OR short_id = ? OR id LIKE ? ORDER BY created_at DESC`).all(idOrPrefix, idOrPrefix, `${idOrPrefix}%`);
+    const alternate = sessionIdFromUuid(idOrPrefix) ?? idOrPrefix;
+    const rows = this.db.prepare(`SELECT * FROM sessions
+          WHERE id = ? OR short_id = ? OR id LIKE ?
+             OR id = ? OR short_id = ? OR id LIKE ?
+          ORDER BY created_at DESC`).all(idOrPrefix, idOrPrefix, `${idOrPrefix}%`, alternate, alternate, `${alternate}%`);
     const row = rows[0];
     return row ? rowToInfo(row) : undefined;
   }
@@ -4023,15 +4253,16 @@ class Store {
   }
 }
 var init_store = __esm(() => {
+  init_src();
   init_paths();
 });
 
 // packages/daemon/src/config-migrate.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 import { Database as Database2 } from "bun:sqlite";
 function checkpointWal(dbFile) {
-  if (!fs9.existsSync(dbFile))
+  if (!fs10.existsSync(dbFile))
     return;
   try {
     const db = new Database2(dbFile);
@@ -4041,30 +4272,30 @@ function checkpointWal(dbFile) {
 }
 function relocate(source, target) {
   try {
-    fs9.renameSync(source, target);
+    fs10.renameSync(source, target);
   } catch {
-    fs9.cpSync(source, target, { recursive: true });
+    fs10.cpSync(source, target, { recursive: true });
   }
 }
 function moveInto(from, to, notes) {
   checkpointWal(path10.join(from, "axterm.db"));
-  fs9.mkdirSync(to, { recursive: true });
+  fs10.mkdirSync(to, { recursive: true });
   for (const entry of STATE_ENTRIES) {
     const source = path10.join(from, entry);
     const target = path10.join(to, entry);
-    if (!fs9.existsSync(source))
+    if (!fs10.existsSync(source))
       continue;
-    if (!fs9.existsSync(target)) {
+    if (!fs10.existsSync(target)) {
       relocate(source, target);
       notes.push(`moved ${entry}`);
       continue;
     }
-    if (!fs9.statSync(source).isDirectory() || !fs9.statSync(target).isDirectory())
+    if (!fs10.statSync(source).isDirectory() || !fs10.statSync(target).isDirectory())
       continue;
     let moved = 0;
-    for (const child of fs9.readdirSync(source)) {
+    for (const child of fs10.readdirSync(source)) {
       const childTarget = path10.join(target, child);
-      if (fs9.existsSync(childTarget))
+      if (fs10.existsSync(childTarget))
         continue;
       relocate(path10.join(source, child), childTarget);
       moved += 1;
@@ -4076,29 +4307,29 @@ function moveInto(from, to, notes) {
 function migrateLegacyConfig(input) {
   const notes = [];
   const storePaths = defaultConfigStorePaths(input.configDir);
-  if (fs9.existsSync(storePaths.configFile))
+  if (fs10.existsSync(storePaths.configFile))
     return { migrated: false, notes };
-  const configSource = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "config.json")));
+  const configSource = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "config.json")));
   if (configSource !== undefined) {
-    fs9.mkdirSync(input.configDir, { recursive: true });
-    fs9.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
+    fs10.mkdirSync(input.configDir, { recursive: true });
+    fs10.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
     const secrets = path10.join(configSource, "secrets.json");
-    if (fs9.existsSync(secrets)) {
-      fs9.copyFileSync(secrets, storePaths.secretsFile);
+    if (fs10.existsSync(secrets)) {
+      fs10.copyFileSync(secrets, storePaths.secretsFile);
       try {
-        fs9.chmodSync(storePaths.secretsFile, 384);
+        fs10.chmodSync(storePaths.secretsFile, 384);
       } catch {}
     }
-    fs9.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
+    fs10.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
   ${input.configDir}
 ` + `These files are no longer used. secrets.json still holds your bot token \u2014 delete this directory once you are satisfied.
 `);
     notes.push(`adopted configuration from ${configSource}`);
   }
-  const legacy = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "axterm.db")));
+  const legacy = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "axterm.db")));
   if (legacy !== undefined) {
     moveInto(legacy, input.stateDir, notes);
-    fs9.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
+    fs10.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
   ${input.stateDir}
 and configuration in:
   ${input.configDir}
@@ -4108,7 +4339,7 @@ and configuration in:
   if (configSource !== undefined)
     return { migrated: true, ...legacy ? { from: legacy } : {}, notes };
   const dbFile = path10.join(input.stateDir, "axterm.db");
-  if (!fs9.existsSync(dbFile))
+  if (!fs10.existsSync(dbFile))
     return { migrated: notes.length > 0, ...legacy ? { from: legacy } : {}, notes };
   const store = new Store(dbFile);
   const machine2 = store.getConfig("axterm_machine");
@@ -4946,13 +5177,13 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
 var init_axterm_agent_status = () => {};
 
 // packages/daemon/src/ext-install.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path11 from "path";
 function installExtensionAsset(targetDir) {
-  fs10.mkdirSync(targetDir, { recursive: true });
+  fs11.mkdirSync(targetDir, { recursive: true });
   const target = path11.join(targetDir, "axterm-agent-status.mjs");
   const js = new Bun.Transpiler({ loader: "ts" }).transformSync(extensionSource);
-  fs10.writeFileSync(target, MANAGED_HEADER + js);
+  fs11.writeFileSync(target, MANAGED_HEADER + js);
   return target;
 }
 var extensionSource, MANAGED_HEADER = `// @axterm-managed-omp-extension
@@ -4965,7 +5196,7 @@ var init_ext_install = __esm(() => {
 
 // packages/daemon/src/workspace-local.ts
 import { spawn as spawn2 } from "child_process";
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import path12 from "path";
 function isAbsent(error) {
   const code = error?.code;
@@ -4979,10 +5210,10 @@ class LocalWorkspace {
     this.stagingDir = stagingDir;
   }
   async list(dir) {
-    const dirents = await fs11.readdir(dir, { withFileTypes: true });
+    const dirents = await fs12.readdir(dir, { withFileTypes: true });
     const stats = await Promise.all(dirents.map(async (dirent) => {
       try {
-        return await fs11.lstat(path12.join(dir, dirent.name));
+        return await fs12.lstat(path12.join(dir, dirent.name));
       } catch (error) {
         if (isAbsent(error))
           return;
@@ -5006,7 +5237,7 @@ class LocalWorkspace {
   }
   async stat(target) {
     try {
-      const stat = await fs11.stat(target);
+      const stat = await fs12.stat(target);
       const kind = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
       return { kind, size: stat.size, mtimeMs: stat.mtimeMs };
     } catch (error) {
@@ -5017,8 +5248,8 @@ class LocalWorkspace {
   }
   async read(file, limit) {
     if (limit === undefined)
-      return await fs11.readFile(file);
-    const handle = await fs11.open(file, "r");
+      return await fs12.readFile(file);
+    const handle = await fs12.open(file, "r");
     try {
       const buffer = Buffer.allocUnsafe(Math.min(limit, (await handle.stat()).size));
       let filled = 0;
@@ -5036,6 +5267,12 @@ class LocalWorkspace {
   materialise(file) {
     return Promise.resolve(file);
   }
+  async mkdirp(dir, mode) {
+    await fs12.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
+  }
+  async write(file, bytes, mode) {
+    await fs12.writeFile(file, bytes, mode === undefined ? undefined : { mode });
+  }
   exec(argv, cwd) {
     const [command, ...args] = argv;
     if (command === undefined)
@@ -5063,7 +5300,7 @@ var init_workspace_local = () => {};
 
 // packages/daemon/src/hook-host.ts
 import { randomBytes } from "crypto";
-import fs12 from "fs";
+import fs13 from "fs";
 import http from "http";
 import path13 from "path";
 function header(req, name) {
@@ -5079,6 +5316,7 @@ class HookHost {
   }
   sessions = new Map;
   pendingAsks = new Map;
+  refusedHooks = new Set;
   endpointFile;
   server;
   askOpenHandler;
@@ -5105,16 +5343,19 @@ class HookHost {
     return promise;
   }
   writeEndpointFile(port) {
-    fs12.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
+    fs13.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
     const tmp = `${this.endpointFile}.tmp`;
-    fs12.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
+    fs13.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
 AXTERM_HOOK_TOKEN=${this.token}
 `);
-    fs12.renameSync(tmp, this.endpointFile);
+    fs13.renameSync(tmp, this.endpointFile);
   }
   registerSession(sessionId, launchToken, onEvent) {
     this.sessions.set(sessionId, { launchToken, onEvent });
   }
+  launchMatches(session, presented) {
+    return session.launchToken === undefined || session.launchToken === presented;
+  }
   unregisterSession(sessionId) {
     this.sessions.delete(sessionId);
     for (const [askId, pending] of this.pendingAsks) {
@@ -5203,7 +5444,7 @@ AXTERM_HOOK_TOKEN=${this.token}
         res.writeHead(404).end();
         return;
       }
-      if (body.launchToken !== session.launchToken) {
+      if (!this.launchMatches(session, body.launchToken)) {
         res.writeHead(403).end();
         return;
       }
@@ -5238,7 +5479,9 @@ AXTERM_HOOK_TOKEN=${this.token}
       return;
     }
     res.writeHead(200).end();
-    this.dispatchHookPayloads(auth.session, map(input), agent);
+    const named = input;
+    const events = withConversationId(map(input), { sessionId: named.session_id, subagentId: named.agent_id });
+    this.dispatchHookPayloads(auth.session, events, agent);
   }
   handleCodex(req, raw, res) {
     const auth = this.agentHookSession(req);
@@ -5294,8 +5537,15 @@ AXTERM_HOOK_TOKEN=${this.token}
     const sessionId = header(req, "x-axterm-session");
     const launchToken = header(req, "x-axterm-launch");
     const session = sessionId === undefined ? undefined : this.sessions.get(sessionId);
-    if (sessionId === undefined || !session || session.launchToken !== launchToken)
+    if (sessionId === undefined || !session || !this.launchMatches(session, launchToken)) {
+      const why = sessionId === undefined ? "no session header" : !session ? "unknown session" : "launch token mismatch";
+      const key = `${req.url}\x00${sessionId ?? ""}\x00${why}`;
+      if (!this.refusedHooks.has(key)) {
+        this.refusedHooks.add(key);
+        log(`refused hook post to ${req.url}: ${why} (session ${sessionId ?? "-"}) \u2014 reported once per session`);
+      }
       return;
+    }
     return { sessionId, session };
   }
   dispatchHookPayloads(session, payloads, agent) {
@@ -5385,7 +5635,7 @@ var init_hook_host = __esm(() => {
 });
 
 // packages/daemon/src/rpc-server.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import net2 from "net";
 function writeFrame(socket, frame) {
   if (!socket.destroyed)
@@ -5495,6 +5745,8 @@ function startRpcServer(options) {
           session.write(Buffer.from(p["dataB64"], "base64").toString("utf8"));
           return {};
         }
+        case "session.choose":
+          return { answered: manager.answerScreenChoice(p["id"], p["index"]) };
         case "attach": {
           const session = manager.resolveLive(p["id"]);
           cleanup();
@@ -5621,7 +5873,7 @@ function startRpcServer(options) {
   });
   if (process.platform !== "win32") {
     try {
-      fs13.unlinkSync(pipePath);
+      fs14.unlinkSync(pipePath);
     } catch {}
   }
   server.listen(pipePath, () => {
@@ -5636,18 +5888,35 @@ var init_rpc_server = __esm(() => {
 });
 
 // packages/daemon/src/codex-home.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function codexTrustKeyPath(home) {
   const resolved = (() => {
     try {
-      return fs14.realpathSync.native(home);
+      return fs15.realpathSync.native(home);
     } catch {
       return path14.resolve(home);
     }
   })();
   return path14.join(resolved, "hooks.json");
 }
+function referenceCredential(source, target, ops) {
+  const symlink = ops?.symlink ?? ((s, t2) => fs15.symlinkSync(s, t2, "file"));
+  const link = ops?.link ?? fs15.linkSync;
+  try {
+    symlink(source, target);
+    return "symlink";
+  } catch {
+    try {
+      link(source, target);
+      return "hardlink";
+    } catch {
+      fs15.copyFileSync(source, target);
+      fs15.chmodSync(target, 384);
+      return "copy";
+    }
+  }
+}
 var init_codex_home = () => {};
 
 // packages/daemon/src/host-env.ts
@@ -5662,15 +5931,36 @@ function stripHostAttribution(env) {
 }
 var ATTRIBUTION_PREFIXES, ATTRIBUTION_KEEP;
 var init_host_env = __esm(() => {
-  ATTRIBUTION_PREFIXES = ["ORCA_"];
+  ATTRIBUTION_PREFIXES = ["ORCA_", "AXTERM_"];
   ATTRIBUTION_KEEP = new Set([
     "ORCA_CODEX_HOME",
     "ORCA_OPENCODE_CONFIG_DIR",
     "ORCA_USER_DATA_PATH",
-    "ORCA_APP_VERSION"
+    "ORCA_APP_VERSION",
+    "AXTERM_CONFIG_DIR",
+    "AXTERM_STATE_DIR",
+    "AXTERM_RUNTIME_DIR",
+    "AXTERM_LANG",
+    "AXTERM_PTY_HOST",
+    "AXTERM_PTY_HOST_MAIN"
   ]);
 });
 
+// packages/daemon/src/session-env.ts
+function sessionEnv(base, identity) {
+  return {
+    ...stripHostAttribution(base),
+    AXTERM_SESSION_ID: identity.sessionId,
+    AXTERM_LAUNCH_TOKEN: identity.launchToken,
+    AXTERM_HOOK_PORT: String(identity.hookPort),
+    AXTERM_HOOK_TOKEN: identity.hookToken,
+    AXTERM_HOOK_ENDPOINT: identity.endpointFile
+  };
+}
+var init_session_env = __esm(() => {
+  init_host_env();
+});
+
 // packages/daemon/src/git-porcelain.ts
 function parseWorktreeList(porcelain) {
   const entries = [];
@@ -5709,7 +5999,7 @@ function slugifyBranch(branch) {
 var MAX_SLUG_LENGTH = 60;
 
 // packages/daemon/src/git.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 async function git(ws, cwd, args) {
   const run = await ws.exec(["git", ...args], cwd);
@@ -5729,7 +6019,7 @@ async function gitOrThrow(ws, cwd, args) {
 function canonicalPath(target) {
   let resolved = path15.resolve(target);
   try {
-    resolved = fs15.realpathSync.native(resolved);
+    resolved = fs16.realpathSync.native(resolved);
   } catch {}
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -5753,7 +6043,7 @@ async function createWorktree(ws, options) {
   const existing = (await listWorktrees(ws, repoRoot)).find((w) => canonicalPath(w.path) === canonicalPath(target));
   if (existing)
     return { path: target, branch, createdBranch: false };
-  fs15.mkdirSync(path15.dirname(target), { recursive: true });
+  fs16.mkdirSync(path15.dirname(target), { recursive: true });
   const exists = (await git(ws, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).ok;
   const args = exists ? ["worktree", "add", target, branch] : ["worktree", "add", "-b", branch, target, ...base !== undefined ? [base] : []];
   await gitOrThrow(ws, repoRoot, args);
@@ -5782,6 +6072,14 @@ async function untrackedFiles(ws, worktreePath) {
     return [];
   return result.stdout.split(/\r?\n/).filter((line) => line.trim().length > 0);
 }
+async function ignoreState(ws, cwd, file) {
+  const run = await ws.exec(["git", "check-ignore", "-q", file], cwd);
+  if (run.code === 0)
+    return "ignored";
+  if (run.code === 1)
+    return "visible";
+  return "unknown";
+}
 async function countLines(ws, filePath) {
   try {
     const stat = await ws.stat(filePath);
@@ -5825,64 +6123,536 @@ async function changedFiles(ws, worktreePath, base, limit = 20) {
         names.add(line.trim());
     }
   }
-  for (const file of await untrackedFiles(ws, worktreePath))
-    names.add(file);
-  return [...names].slice(0, limit);
+  for (const file of await untrackedFiles(ws, worktreePath))
+    names.add(file);
+  return [...names].slice(0, limit);
+}
+var UNTRACKED_LINE_SCAN_LIMIT;
+var init_git = __esm(() => {
+  init_paths();
+  UNTRACKED_LINE_SCAN_LIMIT = 1024 * 1024;
+});
+
+// packages/daemon/src/claude-store.ts
+import fs17 from "fs";
+import os4 from "os";
+import path16 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");
+}
+function resumedConversationId(argv) {
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--resume" || token === "-r") {
+      const value = argv[i + 1];
+      return value !== undefined && CONVERSATION_ID.test(value) ? value : undefined;
+    }
+    const inline = /^--resume=(.+)$/.exec(token);
+    if (inline)
+      return CONVERSATION_ID.test(inline[1]) ? inline[1] : undefined;
+  }
+  return;
+}
+function claudeConversationExists(configDir, conversationId) {
+  const projects = path16.join(configDir, "projects");
+  let entries;
+  try {
+    entries = fs17.readdirSync(projects);
+  } catch {
+    return;
+  }
+  const file = `${conversationId}.jsonl`;
+  for (const entry of entries) {
+    try {
+      if (fs17.existsSync(path16.join(projects, entry, file)))
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function claudeConversationCwd(configDir, conversationId) {
+  const projects = path16.join(configDir, "projects");
+  let entries;
+  try {
+    entries = fs17.readdirSync(projects);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const file = path16.join(projects, entry, `${conversationId}.jsonl`);
+    let head;
+    try {
+      const handle = fs17.openSync(file, "r");
+      try {
+        const buffer = Buffer.alloc(64 * 1024);
+        const read = fs17.readSync(handle, buffer, 0, buffer.byteLength, 0);
+        head = buffer.subarray(0, read).toString("utf8");
+      } finally {
+        fs17.closeSync(handle);
+      }
+    } catch {
+      continue;
+    }
+    for (const line of head.split(/\r?\n/)) {
+      if (line.length === 0)
+        continue;
+      try {
+        const record = JSON.parse(line);
+        const cwd = record.cwd;
+        if (typeof cwd === "string" && cwd.length > 0)
+          return cwd;
+      } catch {}
+    }
+  }
+  return;
+}
+var CONVERSATION_ID;
+var init_claude_store = __esm(() => {
+  CONVERSATION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+});
+
+// packages/daemon/src/injector.ts
+import { setTimeout as delay2 } from "timers/promises";
+
+class Injector {
+  queues = new Map;
+  enqueue(sessionId, task) {
+    const previous = this.queues.get(sessionId) ?? Promise.resolve();
+    const next2 = previous.then(task, task);
+    this.queues.set(sessionId, next2);
+    return next2;
+  }
+  prompt(session, text) {
+    return this.enqueue(session.info.id, async () => {
+      try {
+        const deadline = Date.now() + 5000;
+        while (!session.pasteReady && !session.isExited && Date.now() < deadline) {
+          await delay2(100);
+        }
+        session.write(CTRL_U);
+        await delay2(CLEAR_SETTLE_MS);
+        for (const chunk of iteratePasteChunks(text)) {
+          session.write(chunk);
+        }
+        await delay2(SUBMIT_DELAY_MS);
+        session.write(SUBMIT);
+      } catch (err) {
+        session.write(BRACKETED_PASTE_END);
+        log(`prompt injection failed for ${session.info.shortId}: ${String(err)}`);
+        throw err;
+      }
+    });
+  }
+  interrupt(session) {
+    return this.enqueue(session.info.id, async () => {
+      session.write(ESC);
+      await delay2(500);
+    });
+  }
+}
+var CLEAR_SETTLE_MS = 150;
+var init_injector = __esm(() => {
+  init_src();
+  init_paths();
+});
+
+// packages/daemon/src/pty-host-client.ts
+import net3 from "net";
+import { StringDecoder } from "string_decoder";
+
+class RemotePty {
+  id;
+  pid;
+  send;
+  dataListeners = [];
+  exitListeners = [];
+  decoder = new StringDecoder("utf8");
+  buffered = "";
+  exitCode;
+  exited = false;
+  constructor(id, pid, send) {
+    this.id = id;
+    this.pid = pid;
+    this.send = send;
+  }
+  emit(text) {
+    if (text.length === 0)
+      return;
+    if (this.dataListeners.length === 0) {
+      this.buffered += text;
+      return;
+    }
+    for (const listener of this.dataListeners)
+      listener(text);
+  }
+  push(payload) {
+    this.emit(this.decoder.write(Buffer.from(payload)));
+  }
+  finish(code) {
+    this.emit(this.decoder.end());
+    this.exited = true;
+    this.exitCode = code;
+    for (const listener of this.exitListeners)
+      listener(code);
+  }
+  onData(listener) {
+    this.dataListeners.push(listener);
+    if (this.buffered.length > 0) {
+      const held = this.buffered;
+      this.buffered = "";
+      listener(held);
+    }
+  }
+  onExit(listener) {
+    this.exitListeners.push(listener);
+    if (this.exited)
+      listener(this.exitCode ?? null);
+  }
+  write(data) {
+    this.send(encodeFrame(FrameKind.Data, this.id, new TextEncoder().encode(data)));
+  }
+  resize(cols, rows) {
+    this.send(controlFrame({ t: "resize", id: this.id, cols, rows }));
+  }
+  kill() {
+    if (this.exited)
+      return;
+    this.send(controlFrame({ t: "kill", id: this.id }));
+  }
+}
+function connectPtyHost(options) {
+  return new Promise((resolve, reject) => {
+    const socket = net3.createConnection(options.endpoint);
+    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;
+    const send = (frame) => {
+      if (!socket.destroyed)
+        socket.write(frame);
+    };
+    const fail = (error) => {
+      if (!welcomed)
+        reject(error);
+      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);
+    timer.unref?.();
+    socket.on("error", (err) => fail(err instanceof Error ? err : new Error(String(err))));
+    socket.on("close", () => {
+      clearTimeout(timer);
+      if (!welcomed)
+        reject(new Error("pty host refused the connection"));
+    });
+    socket.on("connect", () => send(controlFrame({ t: "hello", v: PTY_PROTOCOL_VERSION, token: options.token })));
+    socket.on("data", (chunk) => {
+      let frames;
+      try {
+        frames = decoder.push(new Uint8Array(chunk));
+      } catch (err) {
+        fail(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+      for (const frame of frames) {
+        if (frame.kind === FrameKind.Data) {
+          ptys.get(frame.id)?.push(frame.payload);
+          if (dataListeners.length > 0) {
+            let raw = rawDecoders.get(frame.id);
+            if (raw === undefined) {
+              raw = new StringDecoder("utf8");
+              rawDecoders.set(frame.id, raw);
+            }
+            const text = raw.write(Buffer.from(frame.payload));
+            if (text.length > 0)
+              for (const listener of dataListeners)
+                listener(frame.id, text);
+          }
+          continue;
+        }
+        const message = parseControl(frame.payload);
+        if (message === undefined)
+          continue;
+        if (message.t === "welcome") {
+          clearTimeout(timer);
+          welcomed = true;
+          resolve({
+            protocolVersion: message.v,
+            sessions: message.sessions,
+            spawn: (spawnOptions) => new Promise((done, failed) => {
+              const id = spawnOptions.id ?? crypto.randomUUID().replace(/-/g, "");
+              pending.set(id, {
+                resolve: (pid) => {
+                  const pty = new RemotePty(id, pid, send);
+                  ptys.set(id, pty);
+                  done(pty);
+                },
+                reject: failed
+              });
+              send(controlFrame({
+                t: "spawn",
+                id,
+                exe: spawnOptions.exe,
+                argv: spawnOptions.argv,
+                cwd: spawnOptions.cwd,
+                env: Object.fromEntries(Object.entries(spawnOptions.env).filter((entry) => entry[1] !== undefined)),
+                cols: spawnOptions.cols,
+                rows: spawnOptions.rows,
+                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()
+          });
+          continue;
+        }
+        if (message.t === "spawned") {
+          pending.get(message.id)?.resolve(message.pid);
+          pending.delete(message.id);
+          continue;
+        }
+        if (message.t === "error") {
+          pending.get(message.id)?.reject(new Error(message.message));
+          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);
+        }
+      }
+    });
+  });
+}
+var init_pty_host_client = __esm(() => {
+  init_src();
+});
+
+// packages/daemon/src/pty-host-launch.ts
+import { spawn as spawn3 } from "child_process";
+import fs18 from "fs";
+import os5 from "os";
+import path17 from "path";
+function hostFile(runtimeDir) {
+  return path17.join(runtimeDir, "pty-host.json");
+}
+function readPtyHostIn(runtimeDir) {
+  return readPtyHostFile(hostFile(runtimeDir));
+}
+function readPtyHostFile(file) {
+  try {
+    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
+    if (typeof parsed !== "object" || parsed === null)
+      return;
+    const { pid, endpoint, token, version: version2 } = parsed;
+    if (typeof pid !== "number" || typeof endpoint !== "string" || typeof token !== "string")
+      return;
+    return { pid, endpoint, token, version: typeof version2 === "number" ? version2 : PTY_PROTOCOL_VERSION };
+  } catch {
+    return;
+  }
+}
+function isRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function hostEndpoint(runtimeDir) {
+  const base = ipcEndpoint(process.platform, os5.userInfo().username, { runtimeDir });
+  return process.platform === "win32" ? `${base}-pty` : path17.join(runtimeDir, "axterm-pty.sock");
+}
+async function ensurePtyHost(location) {
+  const file = hostFile(location.runtimeDir);
+  const existing = readPtyHostFile(file);
+  if (existing !== undefined && isRunning(existing.pid))
+    return existing;
+  if (existing !== undefined)
+    log(`pty host: handoff file names a dead pid ${existing.pid}, starting a new host`);
+  const endpoint = hostEndpoint(location.runtimeDir);
+  if (process.platform !== "win32")
+    fs18.rmSync(endpoint, { force: true });
+  const token = shortHash(`${location.runtimeDir}:${Date.now()}:${Math.random()}`) + shortHash(String(process.pid));
+  const launch = ptyHostLaunch({ execPath: process.execPath, mainScript: location.mainScript ?? Bun.main });
+  const child = spawn3(launch.command, launch.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      ...location.env,
+      AXTERM_PTY_HOST_ENDPOINT: endpoint,
+      AXTERM_PTY_HOST_TOKEN: token,
+      AXTERM_PTY_HOST_FILE: file
+    }
+  });
+  child.unref();
+  if (child.pid === undefined)
+    throw new Error("could not start the terminal host");
+  const deadline = Date.now() + 15000;
+  for (;; ) {
+    const info = readPtyHostFile(file);
+    if (info !== undefined && info.endpoint === endpoint && isRunning(info.pid))
+      return info;
+    if (Date.now() > deadline)
+      throw new Error(`the terminal host did not become ready within 15s (${endpoint})`);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+function writePtyHostFile(file, info) {
+  fs18.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
+  fs18.writeFileSync(file, `${JSON.stringify(info, null, 2)}
+`, { mode: 384 });
+  restrictFile(file);
+}
+var init_pty_host_launch = __esm(() => {
+  init_src();
+  init_paths();
+  init_shell();
+});
+
+// packages/daemon/src/pty.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import path18 from "path";
+import { StringDecoder as StringDecoder2 } from "string_decoder";
+
+class Fanout {
+  listeners = new Set;
+  backlog = [];
+  add(listener) {
+    this.listeners.add(listener);
+    for (const value of this.backlog)
+      listener(value);
+  }
+  emit(value) {
+    if (this.listeners.size === 0)
+      this.backlog.push(value);
+    else
+      for (const listener of this.listeners)
+        listener(value);
+  }
+}
+function killTree(pid, exeName) {
+  if (process.platform === "win32") {
+    const check = spawnSync2("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 });
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {}
 }
-var UNTRACKED_LINE_SCAN_LIMIT;
-var init_git = __esm(() => {
-  init_paths();
-  UNTRACKED_LINE_SCAN_LIMIT = 1024 * 1024;
-});
 
-// packages/daemon/src/injector.ts
-import { setTimeout as delay2 } from "timers/promises";
-
-class Injector {
-  queues = new Map;
-  enqueue(sessionId, task) {
-    const previous = this.queues.get(sessionId) ?? Promise.resolve();
-    const next2 = previous.then(task, task);
-    this.queues.set(sessionId, next2);
-    return next2;
+class BunPtyHandle {
+  proc;
+  exeName;
+  data = new Fanout;
+  exit = new Fanout;
+  decoder = new StringDecoder2("utf8");
+  exited = false;
+  constructor(proc, exeName) {
+    this.proc = proc;
+    this.exeName = exeName;
   }
-  prompt(session, text) {
-    return this.enqueue(session.info.id, async () => {
-      try {
-        const deadline = Date.now() + 5000;
-        while (!session.pasteReady && !session.isExited && Date.now() < deadline) {
-          await delay2(100);
-        }
-        session.write(CTRL_U);
-        await delay2(CLEAR_SETTLE_MS);
-        for (const chunk of iteratePasteChunks(text)) {
-          session.write(chunk);
-        }
-        await delay2(SUBMIT_DELAY_MS);
-        session.write(SUBMIT);
-      } catch (err) {
-        session.write(BRACKETED_PASTE_END);
-        log(`prompt injection failed for ${session.info.shortId}: ${String(err)}`);
-        throw err;
-      }
-    });
+  get pid() {
+    return this.proc.pid;
   }
-  interrupt(session) {
-    return this.enqueue(session.info.id, async () => {
-      session.write(ESC);
-      await delay2(500);
-    });
+  push(bytes) {
+    const text = this.decoder.write(Buffer.from(bytes));
+    if (text.length > 0)
+      this.data.emit(text);
+  }
+  finish(code) {
+    this.exited = true;
+    const tail = this.decoder.end();
+    if (tail.length > 0)
+      this.data.emit(tail);
+    try {
+      this.proc.terminal.close();
+    } catch {}
+    this.exit.emit(code);
+  }
+  onData(listener) {
+    this.data.add(listener);
+  }
+  onExit(listener) {
+    this.exit.add(listener);
+  }
+  write(data) {
+    this.proc.terminal.write(data);
+  }
+  resize(cols, rows) {
+    this.proc.terminal.resize(cols, rows);
+  }
+  kill() {
+    if (this.exited)
+      return;
+    killTree(this.proc.pid, this.exeName);
+    try {
+      this.proc.kill();
+    } catch {}
   }
 }
-var CLEAR_SETTLE_MS = 150;
-var init_injector = __esm(() => {
-  init_src();
-  init_paths();
-});
+function spawnPty(options) {
+  let handle;
+  const proc = Bun.spawn([options.exe, ...options.argv], {
+    cwd: options.cwd,
+    env: { ...options.env, TERM: options.term },
+    terminal: {
+      cols: options.cols,
+      rows: options.rows,
+      name: options.term,
+      data(_terminal, bytes) {
+        handle?.push(bytes);
+      }
+    }
+  });
+  handle = new BunPtyHandle(proc, path18.basename(options.exe).toLowerCase());
+  proc.exited.then((code) => handle?.finish(code ?? null));
+  return handle;
+}
+var init_pty = () => {};
 
 // packages/daemon/src/occupancy.ts
-import { spawn as spawn3 } from "child_process";
-import fs16 from "fs/promises";
+import { spawn as spawn4 } from "child_process";
+import fs19 from "fs/promises";
 function shellOccupied(shellPid) {
   return process.platform === "win32" ? occupiedFromSnapshot(shellPid) : occupiedFromPidProbe(shellPid);
 }
@@ -5927,11 +6697,11 @@ async function occupiedFromSnapshot(shellPid) {
 }
 async function childrenViaProc(pid) {
   try {
-    const children = await fs16.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    const children = await fs19.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
     return children.trim().length > 0;
   } catch {
     try {
-      await fs16.access(`/proc/${pid}`);
+      await fs19.access(`/proc/${pid}`);
       return;
     } catch {
       return false;
@@ -5978,7 +6748,7 @@ async function processTable() {
 }
 function capture(exe, argv) {
   const { promise, resolve } = Promise.withResolvers();
-  const child = spawn3(exe, argv, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  const child = spawn4(exe, argv, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
   let stdout3 = "";
   child.stdout.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
@@ -5995,20 +6765,20 @@ var init_occupancy = __esm(() => {
 });
 
 // packages/daemon/src/agent-store.ts
-import fs17 from "fs";
-import os4 from "os";
-import path16 from "path";
+import fs20 from "fs";
+import os6 from "os";
+import path19 from "path";
 import { Database as Database3 } from "bun:sqlite";
 function readTailLines(file, maxBytes) {
   let fd;
   try {
-    fd = fs17.openSync(file, "r");
-    const size = fs17.fstatSync(fd).size;
+    fd = fs20.openSync(file, "r");
+    const size = fs20.fstatSync(fd).size;
     if (size === 0)
       return [];
     const length = Math.min(size, maxBytes);
     const buffer = Buffer.allocUnsafe(length);
-    fs17.readSync(fd, buffer, 0, length, size - length);
+    fs20.readSync(fd, buffer, 0, length, size - length);
     const text = buffer.toString("utf8");
     const lines = text.split(`
 `);
@@ -6021,46 +6791,46 @@ function readTailLines(file, maxBytes) {
     return [];
   } finally {
     if (fd !== undefined)
-      fs17.closeSync(fd);
+      fs20.closeSync(fd);
   }
 }
-function claudeConfigDir() {
-  return process.env["CLAUDE_CONFIG_DIR"] ?? path16.join(os4.homedir(), ".claude");
+function claudeConfigDir2() {
+  return process.env["CLAUDE_CONFIG_DIR"] ?? path19.join(os6.homedir(), ".claude");
 }
 function codexHome() {
-  return path16.join(STATE_DIR, "codex-home");
+  return path19.join(STATE_DIR, "codex-home");
 }
 function ompAgentDb() {
-  return path16.join(os4.homedir(), ".omp", "agent", "agent.db");
+  return path19.join(os6.homedir(), ".omp", "agent", "agent.db");
 }
 function findCodexRollout(sessionId) {
-  const root = path16.join(codexHome(), "sessions");
+  const root = path19.join(codexHome(), "sessions");
   for (const shard2 of codexRolloutShards(sessionId)) {
-    const dir = path16.join(root, ...shard2.split("/"));
+    const dir = path19.join(root, ...shard2.split("/"));
     let entries;
     try {
-      entries = fs17.readdirSync(dir);
+      entries = fs20.readdirSync(dir);
     } catch {
       continue;
     }
     const match2 = entries.find((name) => name.endsWith(`-${sessionId}.jsonl`));
     if (match2 !== undefined)
-      return path16.join(dir, match2);
+      return path19.join(dir, match2);
   }
   return;
 }
 function newestCodexRollout() {
-  const root = path16.join(codexHome(), "sessions");
+  const root = path19.join(codexHome(), "sessions");
   let best;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path16.join(dir, entry.name);
+      const full = path19.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (depth < 3)
           walk(full, depth + 1);
@@ -6069,7 +6839,7 @@ function newestCodexRollout() {
       if (!entry.name.endsWith(".jsonl"))
         continue;
       try {
-        const { mtimeMs } = fs17.statSync(full);
+        const { mtimeMs } = fs20.statSync(full);
         if (!best || mtimeMs > best.mtimeMs)
           best = { file: full, mtimeMs };
       } catch {}
@@ -6080,7 +6850,7 @@ function newestCodexRollout() {
 }
 function ompQuotaFacts() {
   const file = ompAgentDb();
-  if (!fs17.existsSync(file))
+  if (!fs20.existsSync(file))
     return { agent: "omp", kind: "gauge" };
   let db;
   try {
@@ -6107,12 +6877,12 @@ function codexQuotaFacts() {
   return reading ? { agent: "codex", kind: "gauge", reading } : { agent: "codex", kind: "gauge" };
 }
 function claudeQuotaFacts(sessions) {
-  const dir = claudeConfigDir();
+  const dir = claudeConfigDir2();
   let newest;
   for (const session of sessions) {
     if (session.agentSessionId === undefined)
       continue;
-    const file = path16.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
+    const file = path19.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
     const event = parseClaudeLimitEvent(readTailLines(file, QUOTA_TAIL_BYTES));
     if (event && (!newest || event.at > newest.at))
       newest = event;
@@ -6144,11 +6914,11 @@ function collectQuotaFacts(agents, sessions, onPath) {
 function storeQuietForMs(agent, cwd, agentSessionId, nowMs) {
   if (agentSessionId === undefined)
     return;
-  const file = agent === "claude" ? path16.join(claudeConfigDir(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
+  const file = agent === "claude" ? path19.join(claudeConfigDir2(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
   if (file === undefined)
     return;
   try {
-    return Math.max(0, nowMs - fs17.statSync(file).mtimeMs);
+    return Math.max(0, nowMs - fs20.statSync(file).mtimeMs);
   } catch {
     return;
   }
@@ -6158,15 +6928,15 @@ function readFileRange(file, from, to) {
     return "";
   let fd;
   try {
-    fd = fs17.openSync(file, "r");
+    fd = fs20.openSync(file, "r");
     const buffer = Buffer.allocUnsafe(to - from);
-    const read = fs17.readSync(fd, buffer, 0, to - from, from);
+    const read = fs20.readSync(fd, buffer, 0, to - from, from);
     return buffer.subarray(0, read).toString("utf8");
   } catch {
     return "";
   } finally {
     if (fd !== undefined)
-      fs17.closeSync(fd);
+      fs20.closeSync(fd);
   }
 }
 var QUOTA_TAIL_BYTES;
@@ -6177,10 +6947,10 @@ var init_agent_store = __esm(() => {
 });
 
 // packages/daemon/src/codex-app-server.ts
-import net3 from "net";
+import net4 from "net";
 async function freeLoopbackPort() {
   const { promise, resolve, reject } = Promise.withResolvers();
-  const probe = net3.createServer();
+  const probe = net4.createServer();
   probe.once("error", reject);
   probe.listen({ host: "127.0.0.1", port: 0 }, () => {
     const address = probe.address();
@@ -6193,7 +6963,7 @@ async function waitForPort(port, timeoutMs = READY_TIMEOUT_MS) {
   const deadline = Date.now() + timeoutMs;
   for (;; ) {
     const open = await new Promise((resolve) => {
-      const socket = net3.connect({ host: "127.0.0.1", port });
+      const socket = net4.connect({ host: "127.0.0.1", port });
       const done = (value) => {
         socket.destroy();
         resolve(value);
@@ -6288,114 +7058,6 @@ var init_codex_app_server = __esm(() => {
   init_paths();
 });
 
-// packages/daemon/src/pty.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import path17 from "path";
-import { StringDecoder } from "string_decoder";
-
-class Fanout {
-  listeners = new Set;
-  backlog = [];
-  add(listener) {
-    this.listeners.add(listener);
-    for (const value of this.backlog)
-      listener(value);
-  }
-  emit(value) {
-    if (this.listeners.size === 0)
-      this.backlog.push(value);
-    else
-      for (const listener of this.listeners)
-        listener(value);
-  }
-}
-function killTree(pid, exeName) {
-  if (process.platform === "win32") {
-    const check = spawnSync2("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 });
-    }
-    return;
-  }
-  try {
-    process.kill(-pid, "SIGKILL");
-  } catch {}
-}
-
-class BunPtyHandle {
-  proc;
-  exeName;
-  data = new Fanout;
-  exit = new Fanout;
-  decoder = new StringDecoder("utf8");
-  exited = false;
-  constructor(proc, exeName) {
-    this.proc = proc;
-    this.exeName = exeName;
-  }
-  get pid() {
-    return this.proc.pid;
-  }
-  push(bytes) {
-    const text = this.decoder.write(Buffer.from(bytes));
-    if (text.length > 0)
-      this.data.emit(text);
-  }
-  finish(code) {
-    this.exited = true;
-    const tail = this.decoder.end();
-    if (tail.length > 0)
-      this.data.emit(tail);
-    try {
-      this.proc.terminal.close();
-    } catch {}
-    this.exit.emit(code);
-  }
-  onData(listener) {
-    this.data.add(listener);
-  }
-  onExit(listener) {
-    this.exit.add(listener);
-  }
-  write(data) {
-    this.proc.terminal.write(data);
-  }
-  resize(cols, rows) {
-    this.proc.terminal.resize(cols, rows);
-  }
-  kill() {
-    if (this.exited)
-      return;
-    killTree(this.proc.pid, this.exeName);
-    try {
-      this.proc.kill();
-    } catch {}
-  }
-}
-function spawnPty(options) {
-  let handle;
-  const proc = Bun.spawn([options.exe, ...options.argv], {
-    cwd: options.cwd,
-    env: { ...options.env, TERM: options.term },
-    terminal: {
-      cols: options.cols,
-      rows: options.rows,
-      name: options.term,
-      data(_terminal, bytes) {
-        handle?.push(bytes);
-      }
-    }
-  });
-  handle = new BunPtyHandle(proc, path17.basename(options.exe).toLowerCase());
-  proc.exited.then((code) => handle?.finish(code ?? null));
-  return handle;
-}
-var init_pty = () => {};
-
 // node_modules/.bun/@xterm+headless@5.5.0/node_modules/@xterm/headless/lib-headless/xterm-headless.js
 var require_xterm_headless = __commonJS((exports) => {
   (() => {
@@ -10725,15 +11387,55 @@ var require_addon_serialize = __commonJS((exports, module) => {
   })());
 });
 
+// packages/daemon/src/terminal-mirror.ts
+class TerminalMirror {
+  scrollbackLines;
+  term;
+  serializeAddon;
+  constructor(cols, rows, scrollbackLines) {
+    this.scrollbackLines = scrollbackLines;
+    this.term = new import_headless.Terminal({ cols, rows, scrollback: scrollbackLines, allowProposedApi: true });
+    this.serializeAddon = new import_addon_serialize.SerializeAddon;
+    this.term.loadAddon(this.serializeAddon);
+  }
+  write(data) {
+    this.term.write(data);
+  }
+  resize(cols, rows) {
+    this.term.resize(cols, rows);
+  }
+  serialize(maxChars = Number.POSITIVE_INFINITY) {
+    const ansi = this.serializeAddon.serialize({ scrollback: this.scrollbackLines });
+    return ansi.length > maxChars ? ansi.slice(-maxChars) : ansi;
+  }
+  text(maxLines) {
+    const buffer = this.term.buffer.active;
+    let last = buffer.length - 1;
+    while (last >= 0 && (buffer.getLine(last)?.translateToString(true).trim() ?? "") === "")
+      last--;
+    const start = Math.max(0, last - maxLines + 1);
+    const lines = [];
+    for (let y = start;y <= last; y++) {
+      lines.push(buffer.getLine(y)?.translateToString(true).trimEnd() ?? "");
+    }
+    return lines.join(`
+`);
+  }
+}
+var import_headless, import_addon_serialize;
+var init_terminal_mirror = __esm(() => {
+  import_headless = __toESM(require_xterm_headless(), 1);
+  import_addon_serialize = __toESM(require_addon_serialize(), 1);
+});
+
 // packages/daemon/src/pty-session.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs21 from "fs";
+import path20 from "path";
 
 class PtySession {
   info;
   pty;
-  term;
-  serializeAddon;
+  mirror;
   dataListeners = new Set;
   exitListeners = new Set;
   saveTimer;
@@ -10742,30 +11444,31 @@ class PtySession {
   pasteReady = false;
   readyScanTail = "";
   lastOutputAt = Date.now();
-  constructor(info, spawn4) {
-    this.info = info;
-    this.term = new import_headless.Terminal({
-      cols: spawn4.cols,
-      rows: spawn4.rows,
-      scrollback: SCROLLBACK_LINES,
-      allowProposedApi: true
-    });
-    this.serializeAddon = new import_addon_serialize.SerializeAddon;
-    this.term.loadAddon(this.serializeAddon);
-    this.pty = spawnPty({
-      exe: spawn4.exe,
-      argv: spawn4.argv,
-      cwd: spawn4.cwd,
-      cols: spawn4.cols,
-      rows: spawn4.rows,
-      env: spawn4.env,
-      term: "xterm-256color"
+  static async open(info, spawn5, spawner = spawnPty) {
+    const pty = await spawner({
+      exe: spawn5.exe,
+      argv: spawn5.argv,
+      cwd: spawn5.cwd,
+      cols: spawn5.cols,
+      rows: spawn5.rows,
+      env: spawn5.env,
+      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.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"))
@@ -10810,27 +11513,16 @@ class PtySession {
     this.info.rows = rows;
     try {
       this.pty.resize(cols, rows);
-      this.term.resize(cols, rows);
+      this.mirror.resize(cols, rows);
     } catch (err) {
       log(`resize failed for ${this.info.shortId}: ${String(err)}`);
     }
   }
   screenText(maxLines = 60) {
-    const buffer = this.term.buffer.active;
-    let last = buffer.length - 1;
-    while (last >= 0 && (buffer.getLine(last)?.translateToString(true).trim() ?? "") === "")
-      last--;
-    const start = Math.max(0, last - maxLines + 1);
-    const lines = [];
-    for (let y = start;y <= last; y++) {
-      lines.push(buffer.getLine(y)?.translateToString(true).trimEnd() ?? "");
-    }
-    return lines.join(`
-`);
+    return this.mirror.text(maxLines);
   }
   serializeBuffer() {
-    const ansi = this.serializeAddon.serialize({ scrollback: SCROLLBACK_LINES });
-    return ansi.length > SCROLLBACK_MAX_CHARS ? ansi.slice(-SCROLLBACK_MAX_CHARS) : ansi;
+    return this.mirror.serialize(SCROLLBACK_MAX_CHARS);
   }
   scheduleSave() {
     if (this.exited || this.saveTimer)
@@ -10843,10 +11535,10 @@ class PtySession {
   }
   saveScrollback() {
     try {
-      const file = path18.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
+      const file = path20.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
       const tmp = `${file}.tmp`;
-      fs18.writeFileSync(tmp, this.serializeBuffer(), "utf8");
-      fs18.renameSync(tmp, file);
+      fs21.writeFileSync(tmp, this.serializeBuffer(), "utf8");
+      fs21.renameSync(tmp, file);
     } catch (err) {
       log(`scrollback save failed for ${this.info.shortId}: ${String(err)}`);
     }
@@ -10857,20 +11549,23 @@ 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 fs19 from "fs";
-import os5 from "os";
-import path19 from "path";
+import { spawn as spawn5 } from "child_process";
+import fs22 from "fs";
+import os7 from "os";
+import path21 from "path";
+function sessionScratchRoot(info) {
+  return info.worktreePath ?? info.cwd;
+}
 function unresolvableAgent(commandOverride, agentCommand, lookup) {
   if (commandOverride !== undefined)
     return;
@@ -10909,6 +11604,14 @@ async function sendableNow(runtime, info, probe, now) {
     occupied
   }, now);
 }
+function pidIsRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 
 class SessionManager {
   store;
@@ -10925,13 +11628,59 @@ class SessionManager {
     this.store = store;
     this.hooks = hooks;
     this.configuredDefaults = configuredDefaults;
-    const stale = store.markStaleRunningAsExited();
-    if (stale > 0)
-      log(`boot: marked ${stale} stale session(s) as exited`);
     this.sessionWatch = setInterval(() => this.tickSessions(), SESSION_TICK_MS);
     this.sessionWatch.unref();
   }
+  async recover() {
+    const running = this.store.listSessions().filter((info) => info.state !== "exited");
+    const held = await this.hostSessions();
+    const adoptedIds = [];
+    for (const info of running) {
+      const description = held.get(info.id);
+      if (description === undefined)
+        continue;
+      try {
+        const handle = await this.ptyHost.adopt(description);
+        info.state = "running";
+        delete info.exitCode;
+        delete info.exitedAt;
+        const session = PtySession.adopt(info, handle, description.cols, description.rows);
+        this.wire(session, undefined);
+        this.hostOwned.add(info.id);
+        this.store.markResumed(info.id, info.agentCommand, info.ptyPid);
+        if (agentIdFromCommand(info.agentCommand) === "codex")
+          this.adoptCodexAppServer(info.id);
+        if (agentIdFromCommand(info.agentCommand) === "gemini")
+          this.skipGeminiTelemetryHistory(info.id);
+        adoptedIds.push(info.id);
+        log(`boot: adopted session ${info.shortId} (pty ${description.pid}) from the terminal host`);
+      } catch (err) {
+        log(`boot: could not adopt ${info.shortId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const sweptExited = this.store.markStaleRunningAsExited(adoptedIds);
+    if (sweptExited > 0)
+      log(`boot: marked ${sweptExited} stale session(s) as exited`);
+    return { adopted: adoptedIds.length, sweptExited };
+  }
+  async hostSessions() {
+    if (process.env["AXTERM_PTY_HOST"] !== "1")
+      return new Map;
+    const existing = readPtyHostIn(RUNTIME_DIR);
+    if (existing === undefined)
+      return new Map;
+    try {
+      this.ptyHost ??= await connectPtyHost({ endpoint: existing.endpoint, token: existing.token });
+      return new Map(this.ptyHost.sessions.map((s) => [s.id, s]));
+    } catch (err) {
+      log(`boot: the terminal host named in pty-host.json did not answer: ${err instanceof Error ? err.message : String(err)}`);
+      return new Map;
+    }
+  }
   sessionWatch;
+  ptyHost;
+  hostOwned = new Set;
+  ptyHostUnavailable = false;
   codexServers = new Map;
   workspaceFor(_sessionId) {
     return this.workspace;
@@ -11009,8 +11758,8 @@ class SessionManager {
     };
   }
   async create(params) {
-    const requestedCwd = params.cwd ? path19.resolve(params.cwd) : os5.homedir();
-    if (!fs19.existsSync(requestedCwd)) {
+    const requestedCwd = params.cwd ? path21.resolve(params.cwd) : os7.homedir();
+    if (!fs22.existsSync(requestedCwd)) {
       throw new AxtermError("err.cwd.missing", { cwd: requestedCwd });
     }
     let worktree;
@@ -11054,11 +11803,27 @@ class SessionManager {
     const missing = unresolvableAgent(params.commandOverride, agentCommand, lookupOnPath);
     if (missing !== undefined)
       throw new AxtermError("err.agent.notInstalled", { command: missing });
+    const adopted = agent === "claude" ? resumedConversationId(agentCommand) : undefined;
+    let sessionCwd = cwd;
+    if (adopted !== undefined) {
+      const holder = conversationHeldBy(this.allSessions(), adopted);
+      if (holder !== undefined) {
+        throw new AxtermError("err.claude.conversationBusy", { id: adopted, session: holder.shortId });
+      }
+      if (worktree === undefined) {
+        const recorded = claudeConversationCwd(claudeConfigDir(), adopted);
+        sessionCwd = resolveSessionCwd({
+          requested: cwd,
+          preferConversation: params.preferConversationCwd === true,
+          ...recorded !== undefined && fs22.existsSync(recorded) ? { conversationCwd: recorded } : {}
+        });
+      }
+    }
     const info = {
       id,
       shortId: id.slice(0, 6),
-      name: params.name ?? worktree?.branch ?? path19.basename(cwd),
-      cwd,
+      name: params.name ?? worktree?.branch ?? path21.basename(sessionCwd),
+      cwd: sessionCwd,
       shell: shell.kind,
       agentCommand,
       state: "running",
@@ -11067,8 +11832,7 @@ class SessionManager {
       createdAt: Date.now(),
       ...worktree !== undefined ? { worktreePath: worktree.path, branch: worktree.branch, repoRoot: worktree.repoRoot } : {}
     };
-    const appServerUrl = agent === "codex" ? await this.startCodexAppServer(id, this.ensureCodexHome(), cwd) : undefined;
-    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 });
@@ -11082,7 +11846,7 @@ class SessionManager {
       launchToken
     });
     const file = this.claudeSettingsPath(id);
-    fs19.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
+    fs22.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
   }
   writeGeminiSettings(sessionId) {
     try {
@@ -11095,69 +11859,104 @@ class SessionManager {
       });
       const file = this.geminiSettingsPath();
       const tmp = `${file}.tmp`;
-      fs19.writeFileSync(tmp, JSON.stringify(settings, null, 2));
-      fs19.renameSync(tmp, file);
+      fs22.writeFileSync(tmp, JSON.stringify(settings, null, 2));
+      fs22.renameSync(tmp, file);
     } catch (err) {
       log(`gemini settings write failed; session starts without hooks: ${String(err)}`);
     }
   }
-  async startCodexAppServer(id, codexHome2, cwd) {
+  async startCodexAppServer(id, codexHome2, cwd, identity) {
     try {
+      const inherited = this.adoptCodexAppServer(id);
+      if (inherited !== undefined)
+        return inherited;
       const port = await freeLoopbackPort();
       const url = `ws://127.0.0.1:${port}`;
-      const proc = Bun.spawn(["codex", "app-server", "--listen", url], {
+      const child = spawn5("codex", ["app-server", "--listen", url], {
         cwd,
-        env: { ...stripHostAttribution(process.env), CODEX_HOME: codexHome2 },
-        stdout: "ignore",
-        stderr: "ignore",
-        stdin: "ignore"
+        detached: true,
+        windowsHide: true,
+        stdio: "ignore",
+        env: { ...sessionEnv(process.env, identity), CODEX_HOME: codexHome2 }
       });
+      child.unref();
+      const pid = child.pid;
+      if (pid === undefined)
+        throw new Error("the app-server was not given a pid");
       if (!await waitForPort(port)) {
-        proc.kill();
+        this.killCodexAppServer(pid);
         log(`codex app-server did not open ${port}; session ${id.slice(0, 6)} keeps its hooks`);
         return;
       }
-      const client = new CodexAppServerClient(url, (payload) => this.ingestHookEvent(id, payload));
-      client.connect();
-      this.codexServers.set(id, {
-        stop: () => {
-          client.close();
-          try {
-            killTree(proc.pid, "codex.exe");
-          } catch {}
-          try {
-            proc.kill();
-          } catch {}
-        }
-      });
-      log(`codex app-server on ${url} for session ${id.slice(0, 6)} in ${cwd}`);
+      this.watchCodexAppServer(id, url, pid);
+      fs22.writeFileSync(this.codexAppServerFile(id), JSON.stringify({ pid, url }), { mode: 384 });
+      log(`codex app-server on ${url} (pid ${pid}) for session ${id.slice(0, 6)} in ${cwd}`);
       return url;
     } catch (err) {
       log(`codex app-server unavailable (${String(err)}); session ${id.slice(0, 6)} keeps its hooks`);
       return;
     }
   }
+  codexAppServerFile(id) {
+    return path21.join(RUNTIME_DIR, `codex-app-${id}.json`);
+  }
+  adoptCodexAppServer(id) {
+    const file = this.codexAppServerFile(id);
+    let record;
+    try {
+      record = JSON.parse(fs22.readFileSync(file, "utf8"));
+    } catch {
+      return;
+    }
+    const pid = record.pid;
+    const url = record.url;
+    if (typeof pid !== "number" || typeof url !== "string")
+      return;
+    if (!pidIsRunning(pid)) {
+      fs22.rmSync(file, { force: true });
+      return;
+    }
+    this.watchCodexAppServer(id, url, pid);
+    log(`codex app-server: reconnected to ${url} (pid ${pid}) for session ${id.slice(0, 6)}`);
+    return url;
+  }
+  watchCodexAppServer(id, url, pid) {
+    const client = new CodexAppServerClient(url, (payload) => this.ingestHookEvent(id, payload));
+    client.connect();
+    this.codexServers.set(id, {
+      stop: () => {
+        client.close();
+        this.killCodexAppServer(pid);
+        fs22.rmSync(this.codexAppServerFile(id), { force: true });
+      }
+    });
+  }
+  killCodexAppServer(pid) {
+    try {
+      killTree(pid, "codex.exe");
+    } catch {}
+  }
   stopCodexAppServer(id) {
     this.codexServers.get(id)?.stop();
     this.codexServers.delete(id);
   }
   ensureCodexHome() {
-    const home = path19.join(STATE_DIR, "codex-home");
-    fs19.mkdirSync(home, { recursive: true, mode: 448 });
+    const home = path21.join(STATE_DIR, "codex-home");
+    fs22.mkdirSync(home, { recursive: true, mode: 448 });
     this.linkCodexAuth(home);
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
     const hooksFile = buildCodexHooks({ command: bridge.command, args: bridge.args });
     const hooksPath = codexTrustKeyPath(home);
     const tmp = `${hooksPath}.tmp`;
-    fs19.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
-    fs19.renameSync(tmp, hooksPath);
+    fs22.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
+    fs22.renameSync(tmp, hooksPath);
     const entries = codexHookTrust(hooksPath, hooksFile);
-    const configPath = path19.join(home, "config.toml");
-    const existing = fs19.existsSync(configPath) ? fs19.readFileSync(configPath, "utf8") : "";
+    const configPath = path21.join(home, "config.toml");
+    const existing = fs22.existsSync(configPath) ? fs22.readFileSync(configPath, "utf8") : "";
     const missing = entries.filter((e) => !existing.includes(`"${e.key.replaceAll("\\", "\\\\")}"`));
     if (missing.length > 0) {
       const block = codexTrustStateToml(missing);
-      fs19.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
+      fs22.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
 `) ? `
 ${block}` : block);
     }
@@ -11170,54 +11969,55 @@ ${block}` : block);
     return home;
   }
   linkCodexAuth(home) {
-    const target = path19.join(home, "auth.json");
-    if (fs19.existsSync(target))
+    const target = path21.join(home, "auth.json");
+    if (fs22.existsSync(target))
       return;
-    const operatorHome = process.env["CODEX_HOME"] ?? path19.join(os5.homedir(), ".codex");
-    const source = path19.join(operatorHome, "auth.json");
-    if (!fs19.existsSync(source))
+    const operatorHome = process.env["CODEX_HOME"] ?? path21.join(os7.homedir(), ".codex");
+    const source = path21.join(operatorHome, "auth.json");
+    if (!fs22.existsSync(source))
       throw new AxtermError("err.codex.noAuth", { authFile: source });
+    let how;
     try {
-      fs19.symlinkSync(source, target, "file");
-    } catch {
-      try {
-        fs19.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 = path19.join(STATE_DIR, "codex-home");
-    const operatorHome = process.env["CODEX_HOME"] ?? path19.join(os5.homedir(), ".codex");
-    const authSource = path19.join(operatorHome, "auth.json");
+    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 geminiSettings = this.geminiSettingsPath();
-    const configPath = path19.join(home, "config.toml");
+    const configPath = path21.join(home, "config.toml");
     const read = (file) => {
       try {
-        return fs19.existsSync(file) ? fs19.readFileSync(file, "utf8") : undefined;
+        return fs22.existsSync(file) ? fs22.readFileSync(file, "utf8") : undefined;
       } catch {
         return;
       }
     };
     return [
-      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs19.existsSync(bridge.command) }),
+      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs22.existsSync(bridge.command) }),
       ...evaluateOmpDoctor({
         binary: lookupOnPath("omp"),
         extensionPath: this.hooks.extensionPath,
-        extensionExists: fs19.existsSync(this.hooks.extensionPath)
+        extensionExists: fs22.existsSync(this.hooks.extensionPath)
       }),
       ...evaluateClaudeDoctor({ binary: lookupOnPath("claude") }),
       ...evaluateCodexDoctor({
         binary: lookupOnPath("codex"),
         authSourcePath: authSource,
-        authSourceExists: fs19.existsSync(authSource),
-        homeExists: fs19.existsSync(home),
+        authSourceExists: fs22.existsSync(authSource),
+        homeExists: fs22.existsSync(home),
         expected: codexHookTrust(codexTrustKeyPath(home), buildCodexHooks({ command: bridge.command, args: bridge.args })),
         configToml: read(configPath)
       }),
-      ...evaluateGeminiDoctor({ binary: lookupOnPath("gemini"), settingsJson: read(geminiSettings) })
+      ...evaluateGeminiDoctor({ binary: lookupOnPath("gemini"), settingsJson: read(geminiSettings) }),
+      ...evaluateStagingDoctor({ mode: this.stagingMode() })
     ];
   }
   quotaReport() {
@@ -11311,6 +12111,18 @@ ${block}` : block);
     session.write(digit);
     return true;
   }
+  answerScreenChoice(idOrPrefix, optionIndex) {
+    const session = this.resolveLive(idOrPrefix);
+    const dialog = detectOnboarding(agentIdFromCommand(session.info.agentCommand), session.screenText(30));
+    const digit = dialog?.options[optionIndex]?.digit;
+    if (digit === undefined) {
+      session.write(buildMenuSelectKeys(optionIndex));
+      return "menu";
+    }
+    this.pendingPrompt.delete(session.info.id);
+    session.write(digit);
+    return "onboarding";
+  }
   sinceLastCapture(id) {
     const at = this.lastCaptureAt.get(id);
     return at === undefined ? undefined : Date.now() - at;
@@ -11337,50 +12149,92 @@ ${block}` : block);
   }
   writeScreenFile(idOrPrefix, lines) {
     const session = this.resolveLive(idOrPrefix);
-    const file = path19.join(path19.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
-    fs19.writeFileSync(file, session.screenText(lines), { mode: 384 });
+    const file = path21.join(path21.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
+    fs22.writeFileSync(file, session.screenText(lines), { mode: 384 });
     return file;
   }
   removeScreenFile(id) {
     try {
-      fs19.rmSync(path19.join(path19.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
+      fs22.rmSync(path21.join(path21.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
     } catch {}
   }
   async stageInboundFile(idOrPrefix, suggestedName, bytes) {
     const info = this.resolveLive(idOrPrefix).info;
-    const file = path19.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
-    await fs19.promises.mkdir(path19.dirname(file), { recursive: true, mode: 448 });
-    await fs19.promises.writeFile(file, bytes, { mode: 384 });
-    log(`session ${info.shortId} staged ${path19.basename(file)} (${bytes.byteLength} bytes)`);
+    if (this.stagingMode() === "runtime")
+      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));
+    await this.prepareScratchDir(ws, dir, file);
+    await ws.write(file, bytes, 384);
+    log(`session ${info.shortId} staged ${path21.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 fs22.promises.mkdir(path21.dirname(file), { recursive: true, mode: 448 });
+    await fs22.promises.writeFile(file, bytes, { mode: 384 });
+    log(`session ${info.shortId} staged ${path21.basename(file)} (${bytes.byteLength} bytes, runtime dir)`);
     return file;
   }
-  removeStagedFiles(id) {
+  async prepareScratchDir(ws, sessionDir, file) {
+    const scratch = scratchDir(sessionDir);
+    const ignore = `${scratch}/${SCRATCH_IGNORE_NAME}`;
     try {
-      fs19.rmSync(path19.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+      await ws.mkdirp(scratch, 448);
+      if (await ws.stat(ignore) === undefined)
+        await ws.write(ignore, new TextEncoder().encode(SCRATCH_IGNORE_BODY));
+    } catch (err) {
+      throw new AxtermError("err.staging.dir", { dir: scratch, error: err instanceof Error ? err.message : String(err) });
+    }
+    if (await ignoreState(ws, sessionDir, file) === "visible") {
+      throw new AxtermError("err.staging.notIgnored", { dir: scratch, file: SCRATCH_IGNORE_NAME });
+    }
+    try {
+      await ws.mkdirp(path21.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 {
+      fs22.rmSync(path21.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+    } catch {}
+    if (info === undefined)
+      return;
+    const scratch = path21.resolve(scratchDir(sessionScratchRoot(info)));
+    try {
+      fs22.rmSync(path21.resolve(inboundStagingDir(sessionScratchRoot(info)), id), { recursive: true, force: true });
+      fs22.rmdirSync(path21.join(scratch, "inbound"));
+      fs22.rmSync(path21.join(scratch, SCRATCH_IGNORE_NAME), { force: true });
+      fs22.rmdirSync(scratch);
     } catch {}
   }
   removeClaudeSettings(id) {
     try {
-      fs19.rmSync(this.claudeSettingsPath(id), { force: true });
-      fs19.rmSync(this.mcpConfigPath(id), { force: true });
-      fs19.rmSync(this.mcpContextPath(id), { force: true });
-      fs19.rmSync(this.geminiTelemetryPath(id), { force: true });
+      fs22.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs22.rmSync(this.mcpConfigPath(id), { force: true });
+      fs22.rmSync(this.mcpContextPath(id), { force: true });
+      fs22.rmSync(this.geminiTelemetryPath(id), { force: true });
       this.stopCodexAppServer(id);
     } catch {}
   }
   claudeSettingsPath(id) {
-    return path19.join(path19.dirname(this.hooks.endpointFile), `claude-${id}.json`);
+    return path21.join(path21.dirname(this.hooks.endpointFile), `claude-${id}.json`);
   }
   mcpConfigPath(id) {
-    return path19.join(path19.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
+    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
   }
   mcpContextPath(id) {
-    return path19.join(path19.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
+    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
   }
   writeMcpContext(id, launchToken) {
     const file = this.mcpContextPath(id);
     try {
-      fs19.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
+      fs22.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp context write failed; session starts without axterm's tools: ${String(err)}`);
@@ -11393,7 +12247,7 @@ ${block}` : block);
   writeMcpConfig(id, contextPath) {
     const file = this.mcpConfigPath(id);
     try {
-      fs19.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
+      fs22.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp config write failed; session starts without axterm's tools: ${String(err)}`);
@@ -11401,12 +12255,38 @@ ${block}` : block);
     }
   }
   geminiTelemetryPath(id) {
-    return path19.join(path19.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
+    return path21.join(path21.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
   }
   geminiSettingsPath() {
-    return path19.join(path19.dirname(this.hooks.endpointFile), "gemini-defaults.json");
+    return path21.join(path21.dirname(this.hooks.endpointFile), "gemini-defaults.json");
+  }
+  async ptySpawner() {
+    if (process.env["AXTERM_PTY_HOST"] !== "1" || 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 } : {} });
+        this.ptyHost = await connectPtyHost({ endpoint: info.endpoint, token: info.token });
+        log(`pty host: connected (pid ${info.pid})`);
+      }
+      const host = this.ptyHost;
+      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 { spawn: spawnPty, hostOwned: false };
+    }
   }
-  launch(info, shell, agentCommand, appServerUrl) {
+  requireClaudeConversation(agentCommand) {
+    const conversation = resumedConversationId(agentCommand);
+    if (conversation === undefined)
+      return;
+    if (claudeConversationExists(claudeConfigDir(), conversation) === false) {
+      throw new AxtermError("err.claude.noConversation", { id: conversation });
+    }
+  }
+  async launch(info, shell, agentCommand) {
     const id = info.id;
     const launchToken = randomBytes2(16).toString("hex");
     const agentId = agentIdFromCommand(info.agentCommand);
@@ -11414,22 +12294,30 @@ ${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;
-    const session = new PtySession(info, {
+    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)),
       cwd: info.cwd,
       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",
@@ -11440,7 +12328,15 @@ ${block}` : block);
         } : {},
         ...codexHome2 !== undefined ? { CODEX_HOME: codexHome2 } : {}
       }
-    });
+    }, 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(() => {
@@ -11456,7 +12352,7 @@ ${block}` : block);
       this.hooks.host.unregisterSession(id);
       this.removeClaudeSettings(id);
       this.removeScreenFile(id);
-      this.removeStagedFiles(id);
+      this.removeStagedFiles(id, info);
       clearTimeout(this.idleTimers.get(id));
       this.idleTimers.delete(id);
       this.sawOutput.delete(id);
@@ -11467,11 +12363,11 @@ ${block}` : block);
       this.pendingPrompt.delete(id);
       this.live.delete(id);
       this.agentRuntime.delete(id);
+      this.hostOwned.delete(id);
       log(`session ${info.shortId} exited code=${code}`);
       this.emit({ t: "session.exit", sessionId: id, code });
     });
     this.live.set(id, session);
-    return session;
   }
   emitActivity(id, payload) {
     const dropped = payload.dropped;
@@ -11615,7 +12511,8 @@ ${block}` : block);
     const direct = this.live.get(idOrPrefix);
     if (direct)
       return direct;
-    const matches = [...this.live.values()].filter((s) => s.info.id.startsWith(idOrPrefix) || s.info.shortId === idOrPrefix || s.info.name === idOrPrefix);
+    const alternate = sessionIdFromUuid(idOrPrefix);
+    const matches = [...this.live.values()].filter((s) => s.info.id.startsWith(idOrPrefix) || s.info.shortId === idOrPrefix || s.info.name === idOrPrefix || alternate !== undefined && s.info.id.startsWith(alternate));
     if (matches.length === 1)
       return matches[0];
     if (matches.length > 1)
@@ -11641,37 +12538,14 @@ ${block}` : block);
   allSessions() {
     return sessionsByRecency([...this.live.values()].map((s) => s.info), this.store.listSessions());
   }
-  resumeNamed(stored, agent) {
-    if (!fs19.existsSync(stored.cwd))
-      throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
-    const agentCommand = buildAgentResumeCommand({
-      agent,
-      sessionId: stored.id,
-      extensionPath: this.hooks.extensionPath,
-      claudeSettingsPath: this.claudeSettingsPath(stored.id)
-    });
-    const info = { ...stored, agentCommand, state: "running" };
-    delete info.exitCode;
-    delete info.exitedAt;
-    delete info.agentState;
-    delete info.agentStateSource;
-    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,
@@ -11682,7 +12556,7 @@ ${block}` : block);
     if (agentCommand === undefined) {
       throw new AxtermError("err.session.noResumeSupport", { agent: profile.displayName });
     }
-    if (!fs19.existsSync(stored.cwd))
+    if (!fs22.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const info = { ...stored, agentCommand, state: "running" };
     delete info.exitCode;
@@ -11690,8 +12564,7 @@ ${block}` : block);
     delete info.agentState;
     delete info.agentStateSource;
     const shell = resolveShell(info.shell);
-    const resumedAppServer = agentIdFromCommand(agentCommand) === "codex" ? await this.startCodexAppServer(info.id, this.ensureCodexHome(), info.cwd) : undefined;
-    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 });
@@ -11732,7 +12605,8 @@ ${block}` : block);
       if (err instanceof AxtermError && err.key === "err.session.ambiguous")
         throw err;
     }
-    const id = live?.info.id ?? this.store.findByPrefix(idOrPrefix)?.id;
+    const info = live?.info ?? this.store.findByPrefix(idOrPrefix);
+    const id = info?.id;
     if (id === undefined)
       throw new AxtermError("err.session.missing", { id: idOrPrefix });
     if (live !== undefined && !live.isExited) {
@@ -11747,7 +12621,7 @@ ${block}` : block);
       await promise;
     }
     this.removeScreenFile(id);
-    this.removeStagedFiles(id);
+    this.removeStagedFiles(id, info);
     this.removeClaudeSettings(id);
     this.removeScrollback(id);
     this.store.deleteSession(id);
@@ -11756,7 +12630,7 @@ ${block}` : block);
   removeScrollback(id) {
     for (const file of [`${id}.bin`, `${id}.bin.tmp`]) {
       try {
-        fs19.rmSync(path19.join(SCROLLBACK_DIR, file), { force: true });
+        fs22.rmSync(path21.join(SCROLLBACK_DIR, file), { force: true });
       } catch {}
     }
   }
@@ -11764,6 +12638,14 @@ ${block}` : block);
     this.drainGeminiTelemetry();
     this.watchForStalls();
   }
+  skipGeminiTelemetryHistory(id) {
+    const runtime = this.agentRuntime.get(id);
+    if (runtime === undefined)
+      return;
+    try {
+      runtime.telemetryOffset = fs22.statSync(this.geminiTelemetryPath(id)).size;
+    } catch {}
+  }
   drainGeminiTelemetry() {
     for (const [id, session] of this.live) {
       if (agentIdFromCommand(session.info.agentCommand) !== "gemini")
@@ -11774,7 +12656,7 @@ ${block}` : block);
       const file = this.geminiTelemetryPath(id);
       let size = 0;
       try {
-        size = fs19.statSync(file).size;
+        size = fs22.statSync(file).size;
       } catch {
         continue;
       }
@@ -11836,10 +12718,17 @@ ${block}` : block);
     clearInterval(this.sessionWatch);
     for (const id of [...this.codexServers.keys()])
       this.stopCodexAppServer(id);
-    for (const session of this.live.values()) {
+    let handedOn = 0;
+    for (const [id, session] of this.live) {
       session.saveScrollback();
+      if (this.hostOwned.has(id)) {
+        handedOn += 1;
+        continue;
+      }
       session.kill();
     }
+    if (handedOn > 0)
+      log(`left ${handedOn} session(s) running in the terminal host for the next daemon`);
     this.live.clear();
     this.agentRuntime.clear();
   }
@@ -11848,9 +12737,13 @@ 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();
+  init_pty_host_client();
+  init_pty_host_launch();
+  init_pty();
   init_occupancy();
   init_agent_store();
   init_codex_app_server();
@@ -11859,7 +12752,7 @@ var init_session_manager = __esm(() => {
   init_pty_session();
   init_shell();
   init_workspace_local();
-  MATERIALISED_DIR = path19.join(RUNTIME_DIR, "materialised");
+  MATERIALISED_DIR = path21.join(RUNTIME_DIR, "materialised");
   PROMPT_OPTIONS = {
     hostKey: [{ label: "yes" }, { label: "no" }],
     password: [],
@@ -11890,6 +12783,9 @@ class FetchTelegramApi {
       throw new Error(`telegram file download failed: ${res.status}`);
     return new Uint8Array(await res.arrayBuffer());
   }
+  async deleteMessage(chatId, messageId) {
+    await this.call("deleteMessage", { chat_id: chatId, message_id: messageId });
+  }
   async call(method, params = {}) {
     const attempt = async () => {
       const res = await fetch(`https://api.telegram.org/bot${this.botToken}/${method}`, {
@@ -12008,11 +12904,11 @@ var init_acknowledge = __esm(() => {
 });
 
 // packages/channel-telegram/src/attach.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path22 from "path";
 function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELEGRAM_LIMITS) {
-  const name = path20.basename(filePath);
-  const bytes = fs20.statSync(filePath).size;
+  const name = path22.basename(filePath);
+  const bytes = fs23.statSync(filePath).size;
   const plan = planAttachment({ name, bytes }, limits);
   if (plan.kind === "rejected")
     throw new Error(plan.reason);
@@ -12022,7 +12918,7 @@ function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELE
   form.append("message_thread_id", String(topicId));
   if (caption !== undefined && caption.length > 0)
     form.append("caption", caption);
-  form.append(field, new Blob([fs20.readFileSync(filePath)]), name);
+  form.append(field, new Blob([fs23.readFileSync(filePath)]), name);
   return { method: plan.kind === "photo" ? "sendPhoto" : "sendDocument", field, form };
 }
 function isPhotoRejection(error) {
@@ -12030,13 +12926,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 = path20.basename(filePath);
+  const name = path22.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([fs20.readFileSync(filePath)]), name);
+  form.append("document", new Blob([fs23.readFileSync(filePath)]), name);
   return { method: "sendDocument", field: "document", form };
 }
 var TELEGRAM_LIMITS;
@@ -12622,6 +13518,7 @@ class TelegramChannel {
   updateOffset = 0;
   albums = new Map;
   inboundQueues = new Map;
+  refusedAlbums = new Map;
   albumDebounceMs;
   inboundLimits;
   inboundEnabled;
@@ -12931,6 +13828,26 @@ ${code(prompt.line)}`,
     });
   }
   awaitingSecret = new Map;
+  async captureSecret(sessionId, msg, text) {
+    const seq = this.awaitingSecret.get(sessionId);
+    if (seq === undefined)
+      return false;
+    this.awaitingSecret.delete(sessionId);
+    const accepted = this.control.answerShellPrompt(sessionId, seq, text);
+    let deleted = false;
+    if (this.api.deleteMessage && msg.chat && msg.message_id !== undefined) {
+      try {
+        await this.api.deleteMessage(msg.chat.id, msg.message_id);
+        deleted = true;
+      } catch (err) {
+        this.log(`secret reply message ${msg.message_id} not deleted: ${String(err)}`);
+      }
+    }
+    await this.sendToSession(sessionId, tHtml(accepted ? "tg.prompt.secretSubmitted" : "tg.prompt.secretStale"));
+    if (!deleted)
+      await this.sendToSession(sessionId, tHtml("tg.prompt.secretUndeleted"));
+    return true;
+  }
   async onChoiceRequest(sessionId, seq, questions, askId, onboarding2 = false) {
     const binding = this.control.findBindingBySession(sessionId);
     if (!binding || questions.length === 0)
@@ -13076,6 +13993,10 @@ ${code(prompt.line)}`,
     if (!msg.from || !this.config.allowedUserIds.includes(msg.from.id))
       return;
     const binding = msg.message_thread_id ? this.control.findBindingByTopic(msg.chat.id, msg.message_thread_id) : undefined;
+    if (msg.message_thread_id !== undefined && binding === undefined) {
+      this.log(`ignored update in topic ${msg.message_thread_id}: not this machine's`);
+      return;
+    }
     const media = readMedia(msg);
     if (media) {
       await this.handleMedia(msg, binding, media);
@@ -13090,6 +14011,8 @@ ${code(prompt.line)}`,
     }
     if (!binding)
       return;
+    if (await this.captureSecret(binding.sessionId, msg, text))
+      return;
     if (await this.captureFreeText(binding.sessionId, text))
       return;
     const chatId = msg.chat.id;
@@ -13108,28 +14031,47 @@ ${code(prompt.line)}`,
       return;
     }
     if (!binding) {
-      await this.refuseMedia(msg, tHtml("tg.inbound.noSession"));
+      await this.refuseMedia(msg, tHtml("tg.inbound.noSession"), "no session bound to the topic");
       return;
     }
     const plan = planInboundAttachment(media.candidate, this.inboundLimits);
     if (!plan.ok) {
-      await this.refuseMedia(msg, tHtml(REFUSAL_KEYS[plan.reason], { limit: megabytes2(this.inboundLimits.maxBytes) }));
+      const text = tHtml(REFUSAL_KEYS[plan.reason], { limit: megabytes2(this.inboundLimits.maxBytes) });
+      await this.refuseMedia(msg, text, plan.reason);
       return;
     }
     await this.react(msg.chat?.id, msg.message_id, "received");
     this.bufferMedia(msg, binding.sessionId, { fileId: media.fileId, name: plan.name, kind: plan.kind, messageId: msg.message_id });
   }
-  async refuseMedia(msg, text) {
+  async refuseMedia(msg, text, reason) {
     const chatId = msg.chat?.id;
+    const where = `chat ${chatId ?? "?"} topic ${msg.message_thread_id ?? "general"}`;
+    const album = msg.media_group_id !== undefined ? ` album ${msg.media_group_id}` : "";
+    this.log(`inbound refused (${reason}) in ${where}${album}, message ${msg.message_id ?? "?"}`);
     await this.react(chatId, msg.message_id, "failed");
     if (chatId === undefined)
       return;
+    if (this.albumAlreadyRefused(msg, reason))
+      return;
+    const attributed = msg.message_thread_id === undefined ? `[${escapeHtml(this.config.machine.name)}] ${text}` : text;
     await sendFormatted(this.api, {
       chat_id: chatId,
       ...msg.message_thread_id !== undefined ? { message_thread_id: msg.message_thread_id } : {},
-      text
+      text: attributed
     }).catch((err) => this.log(`inbound refusal failed: ${String(err)}`));
   }
+  albumAlreadyRefused(msg, reason) {
+    const group = msg.media_group_id;
+    if (group === undefined)
+      return false;
+    const key = `${group}\x00${reason}`;
+    const pending = this.refusedAlbums.get(key);
+    clearTimeout(pending);
+    const timer = setTimeout(() => this.refusedAlbums.delete(key), this.albumDebounceMs);
+    timer.unref?.();
+    this.refusedAlbums.set(key, timer);
+    return pending !== undefined;
+  }
   bufferMedia(msg, sessionId, item) {
     const group = msg.media_group_id;
     const caption = msg.caption?.trim();
@@ -13177,8 +14119,8 @@ ${code(prompt.line)}`,
         throw new Error("this Telegram client cannot download files");
       const files = [];
       for (const item of batch.items) {
-        const path21 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
-        files.push({ path: path21, kind: item.kind });
+        const path23 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
+        files.push({ path: path23, kind: item.kind });
       }
       await this.control.prompt(batch.sessionId, buildAttachmentPrompt(files, batch.caption));
       this.log(`staged ${files.length} inbound file(s) for ${batch.sessionId}`);
@@ -13301,8 +14243,15 @@ ${code(prompt.line)}`,
         const project = await resolveProject(args[0]);
         if (!project)
           return;
-        const name = args.slice(1).join(" ") || undefined;
-        await this.control.createSession({ cwd: project.path, ...name !== undefined ? { name } : {} });
+        const tail = args.slice(1);
+        const flagAt = tail.findIndex((token) => token.startsWith("-"));
+        const name = (flagAt < 0 ? tail : tail.slice(0, flagAt)).join(" ") || undefined;
+        const agentArgs = flagAt < 0 ? [] : tail.slice(flagAt);
+        await this.control.createSession({
+          cwd: project.path,
+          ...name !== undefined ? { name } : {},
+          ...agentArgs.length > 0 ? { agentArgs } : {}
+        });
         return;
       }
       case "/wt": {
@@ -13572,13 +14521,13 @@ var init_src2 = __esm(() => {
 });
 
 // packages/daemon/src/machine-identity.ts
-import os6 from "os";
+import os8 from "os";
 function resolveMachineIdentity(override) {
-  const hostname = os6.hostname();
+  const hostname = os8.hostname();
   return {
     name: slugifyMachineName(override && override.trim().length > 0 ? override : hostname),
     hostname,
-    addresses: collectAddresses(os6.networkInterfaces())
+    addresses: collectAddresses(os8.networkInterfaces())
   };
 }
 var init_machine_identity = __esm(() => {
@@ -13590,13 +14539,15 @@ class TelegramService {
   config;
   store;
   manager;
+  apiFactory;
   channel;
   unsubscribe;
   runningConfig;
-  constructor(config, store, manager) {
+  constructor(config, store, manager, apiFactory = (token) => new FetchTelegramApi(token)) {
     this.config = config;
     this.store = store;
     this.manager = manager;
+    this.apiFactory = apiFactory;
   }
   readSettings() {
     const telegram = this.config.resolved().channels.telegram;
@@ -13645,7 +14596,7 @@ class TelegramService {
     const token = botToken ?? this.readSettings().botToken;
     if (!token)
       throw new AxtermError("err.telegram.noToken");
-    const api = new FetchTelegramApi(token);
+    const api = this.apiFactory(token);
     const updates = await api.call("getUpdates", { timeout: 0 });
     return discoverTelegramTargets(updates);
   }
@@ -13660,7 +14611,7 @@ class TelegramService {
       log("telegram: not configured, channel not started");
       return false;
     }
-    const api = new FetchTelegramApi(s.botToken);
+    const api = this.apiFactory(s.botToken);
     const config = {
       groupId: s.groupId,
       allowedUserIds: [s.allowUserId],
@@ -13808,8 +14759,8 @@ var init_telegram_service = __esm(() => {
 // packages/daemon/src/index.ts
 var exports_src = {};
 import { randomBytes as randomBytes3 } from "crypto";
-import fs21 from "fs";
-import net4 from "net";
+import fs24 from "fs";
+import net5 from "net";
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -13820,9 +14771,9 @@ function isPidAlive(pid) {
 }
 async function main() {
   ensureDataDirs();
-  if (fs21.existsSync(RUNTIME_FILE2)) {
+  if (fs24.existsSync(RUNTIME_FILE2)) {
     try {
-      const existing = JSON.parse(fs21.readFileSync(RUNTIME_FILE2, "utf8"));
+      const existing = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
       if (existing.pid !== process.pid && isPidAlive(existing.pid)) {
         log(`daemon already running (pid ${existing.pid}); exiting`);
         process.exit(0);
@@ -13845,7 +14796,7 @@ async function main() {
     version: productVersion(),
     startedAt: Date.now()
   };
-  fs21.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
+  fs24.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
   restrictFile(RUNTIME_FILE2);
   const config = new ConfigStore(defaultConfigStorePaths(CONFIG_DIR));
   if (config.loadError !== undefined)
@@ -13897,12 +14848,15 @@ async function main() {
     hookHost.stop();
     store.close();
     try {
-      const current = JSON.parse(fs21.readFileSync(RUNTIME_FILE2, "utf8"));
+      const current = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
       if (current.pid === process.pid)
-        fs21.rmSync(RUNTIME_FILE2);
+        fs24.rmSync(RUNTIME_FILE2);
     } catch {}
     process.exit(0);
   };
+  const recovered = await manager.recover();
+  if (recovered.adopted > 0)
+    log(`boot: ${recovered.adopted} session(s) adopted from the terminal host`);
   startRpcServer({
     pipePath: PIPE_PATH,
     token,
@@ -13932,14 +14886,219 @@ var init_src3 = __esm(() => {
   init_session_manager();
   init_telegram_service();
   init_store();
-  net4.setDefaultAutoSelectFamilyAttemptTimeout(3000);
+  net5.setDefaultAutoSelectFamilyAttemptTimeout(3000);
   main();
 });
 
+// packages/daemon/src/pty-host.ts
+import net6 from "net";
+function startPtyHost(options) {
+  const sessions = new Map;
+  const clients = new Set;
+  const send = (socket, reply) => {
+    if (!socket.destroyed)
+      socket.write(controlFrame(reply));
+  };
+  const broadcast = (frame) => {
+    for (const client of clients)
+      if (!client.destroyed)
+        client.write(frame);
+  };
+  const server = net6.createServer((socket) => {
+    const decoder = new FrameDecoder;
+    let greeted = false;
+    const drop = (reason) => {
+      log(`pty host: dropping client (${reason})`);
+      socket.destroy();
+      clients.delete(socket);
+    };
+    socket.on("close", () => clients.delete(socket));
+    socket.on("error", () => clients.delete(socket));
+    socket.on("data", (chunk) => {
+      let frames;
+      try {
+        frames = decoder.push(new Uint8Array(chunk));
+      } catch (err) {
+        drop(err instanceof Error ? err.message : String(err));
+        return;
+      }
+      for (const frame of frames) {
+        if (frame.kind === FrameKind.Data) {
+          if (!greeted)
+            return drop("data before hello");
+          const session = sessions.get(frame.id);
+          if (session && !session.exited)
+            session.handle.write(new TextDecoder().decode(frame.payload));
+          continue;
+        }
+        const message = parseControl(frame.payload);
+        if (message === undefined)
+          continue;
+        if (message.t === "hello") {
+          if (message.token !== options.token)
+            return drop("bad token");
+          greeted = true;
+          clients.add(socket);
+          send(socket, {
+            t: "welcome",
+            v: PTY_PROTOCOL_VERSION,
+            sessions: [...sessions.entries()].filter(([, s]) => !s.exited).map(([id, s]) => ({ id, pid: s.handle.pid, cols: s.cols, rows: s.rows }))
+          });
+          continue;
+        }
+        if (!greeted)
+          return drop("control before hello");
+        if (message.t === "spawn") {
+          try {
+            const handle = spawnPty({
+              exe: message.exe,
+              argv: message.argv,
+              cwd: message.cwd,
+              cols: message.cols,
+              rows: message.rows,
+              env: message.env,
+              term: message.term
+            });
+            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) => {
+              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)
+                send(client, { t: "exit", id: message.id, code: code2 });
+              sessions.delete(message.id);
+              if (sessions.size === 0)
+                options.onIdle?.();
+            });
+            send(socket, { t: "spawned", id: message.id, pid: handle.pid });
+          } catch (err) {
+            send(socket, { t: "error", id: message.id, message: err instanceof Error ? err.message : String(err) });
+          }
+          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)
+            continue;
+          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") {
+          sessions.get(message.id)?.handle.kill();
+        }
+      }
+    });
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.endpoint, () => {
+      server.removeListener("error", reject);
+      log(`pty host: listening on ${options.endpoint}`);
+      resolve({
+        endpoint: options.endpoint,
+        get sessionCount() {
+          return sessions.size;
+        },
+        close: async () => {
+          for (const client of clients)
+            client.destroy();
+          clients.clear();
+          for (const session of sessions.values())
+            session.handle.kill();
+          await new Promise((done) => server.close(() => done()));
+        }
+      });
+    });
+  });
+}
+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
+var exports_pty_host_main = {};
+__export(exports_pty_host_main, {
+  runPtyHostProcess: () => runPtyHostProcess,
+  PTY_HOST_IDLE_MS: () => PTY_HOST_IDLE_MS
+});
+async function runPtyHostProcess() {
+  const endpoint = process.env["AXTERM_PTY_HOST_ENDPOINT"];
+  const token = process.env["AXTERM_PTY_HOST_TOKEN"];
+  const file = process.env["AXTERM_PTY_HOST_FILE"];
+  if (!endpoint || !token || !file) {
+    console.error("axterm __pty-host: AXTERM_PTY_HOST_ENDPOINT, _TOKEN and _FILE are required");
+    process.exitCode = 2;
+    return;
+  }
+  let idleTimer;
+  const server = await startPtyHost({
+    endpoint,
+    token,
+    onIdle: () => armIdleExit()
+  });
+  function armIdleExit() {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      if (server.sessionCount > 0)
+        return armIdleExit();
+      log("pty host: idle with no sessions, exiting");
+      server.close().then(() => process.exit(0));
+    }, PTY_HOST_IDLE_MS);
+    idleTimer.unref?.();
+  }
+  writePtyHostFile(file, { pid: process.pid, endpoint, token, version: PTY_PROTOCOL_VERSION });
+  log(`pty host: ready on ${endpoint} (pid ${process.pid})`);
+  armIdleExit();
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      server.close().then(() => process.exit(0));
+    });
+  }
+}
+var PTY_HOST_IDLE_MS = 60000;
+var init_pty_host_main = __esm(() => {
+  init_src();
+  init_paths();
+  init_pty_host_launch();
+  init_pty_host();
+});
+
 // packages/cli/src/index.ts
 init_src();
-import fs22 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path23 from "path";
 
 // packages/cli/src/attach.ts
 import fs from "fs";
@@ -14541,6 +15700,7 @@ async function ensureDaemon() {
 
 // packages/cli/src/hook-bridge.ts
 init_src();
+import fs3 from "fs";
 var POST_TIMEOUT_MS = 1500;
 function isCodexApproval(agent, body) {
   if (agent !== "codex")
@@ -14565,23 +15725,43 @@ async function relayHookEvent(agent) {
     if (body === "")
       return;
     const approval = isCodexApproval(agent, body);
-    const res = await fetch(target.url, {
-      method: "POST",
-      headers: target.headers,
-      body,
-      signal: AbortSignal.timeout(approval ? CODEX_APPROVAL_POST_TIMEOUT_MS : POST_TIMEOUT_MS)
-    });
-    if (approval && res.ok) {
+    const timeout = approval ? CODEX_APPROVAL_POST_TIMEOUT_MS : POST_TIMEOUT_MS;
+    const post = (to) => fetch(to.url, { method: "POST", headers: to.headers, body, signal: AbortSignal.timeout(timeout) });
+    let res;
+    try {
+      res = await post(target);
+    } catch {}
+    if (res === undefined || res.status === 401 || res.status === 404) {
+      if (approval && res === undefined)
+        return;
+      const fresh = currentEndpoint();
+      const retarget = fresh === undefined ? undefined : hookPostTarget(process.env, agent, fresh);
+      if (retarget !== undefined && retarget.url !== target.url)
+        res = await post(retarget);
+      else if (res === undefined)
+        return;
+    }
+    if (approval && res !== undefined && res.ok) {
       const decision = await res.text();
       if (decision !== "")
         process.stdout.write(decision);
     }
   } catch {}
 }
+function currentEndpoint() {
+  const file = process.env["AXTERM_HOOK_ENDPOINT"];
+  if (file === undefined)
+    return;
+  try {
+    return parseHookEndpoint(fs3.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}
 
 // packages/cli/src/mcp-server.ts
 init_src();
-import fs3 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 var ASK_TIMEOUT_MS = 10 * 60000;
 var POST_TIMEOUT_MS2 = 5000;
@@ -14698,7 +15878,7 @@ class McpServer {
     const contextFile = this.io.env[MCP_CONTEXT_ENV];
     if (contextFile !== undefined) {
       try {
-        const context = JSON.parse(fs3.readFileSync(contextFile, "utf8"));
+        const context = JSON.parse(fs4.readFileSync(contextFile, "utf8"));
         if (context.port && context.token && context.sessionId) {
           return {
             url: `http://127.0.0.1:${context.port}`,
@@ -14855,13 +16035,13 @@ function runMcpServer() {
 init_src();
 import { spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs4 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 // packages/cli/package.json
 var package_default = {
   name: "@layorixinc/axterm",
-  version: "0.4.0",
+  version: "0.6.0",
   type: "module",
   bin: {
     axterm: "dist/cli.js"
@@ -14935,7 +16115,7 @@ function assetName(platform, arch, isMusl) {
 function usesMusl() {
   if (process.platform !== "linux")
     return false;
-  if (fs4.existsSync("/etc/alpine-release"))
+  if (fs5.existsSync("/etc/alpine-release"))
     return true;
   const ldd = spawnSync("ldd", ["--version"], { encoding: "utf8" });
   return `${ldd.stdout ?? ""}${ldd.stderr ?? ""}`.toLowerCase().includes("musl");
@@ -14949,7 +16129,7 @@ function firstLine(command, args) {
 function detectOrigin(execPath) {
   const resolved = (() => {
     try {
-      return fs4.realpathSync(execPath);
+      return fs5.realpathSync(execPath);
     } catch {
       return execPath;
     }
@@ -14991,7 +16171,7 @@ function checksumFor(sums, asset) {
   return;
 }
 function sha256(file) {
-  return createHash2("sha256").update(fs4.readFileSync(file)).digest("hex");
+  return createHash2("sha256").update(fs5.readFileSync(file)).digest("hex");
 }
 function ask2(question) {
   if (stdin2.isTTY !== true)
@@ -15038,7 +16218,7 @@ async function runUpdate(client, current, options) {
   }
   const asset = assetName(process.platform, process.arch, usesMusl());
   const base = `${RELEASES}/v${latest.version}`;
-  const staging = fs4.mkdtempSync(`${process.execPath}.update-`);
+  const staging = fs5.mkdtempSync(`${process.execPath}.update-`);
   const downloaded = path5.join(staging, asset);
   try {
     console.log(t("cli.update.downloading", { asset }));
@@ -15052,7 +16232,7 @@ async function runUpdate(client, current, options) {
       return;
     }
     if (process.platform !== "win32")
-      fs4.chmodSync(downloaded, 493);
+      fs5.chmodSync(downloaded, 493);
     const reported = spawnSync(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
     if (reported !== latest.version) {
       console.error(t("cli.update.wrongVersion", { got: reported ?? "nothing", want: latest.version }));
@@ -15092,7 +16272,7 @@ async function runUpdate(client, current, options) {
         console.log(t("cli.update.restoreFailed", { id, reason: (result.stderr ?? "").trim() || "unknown" }));
     }
   } finally {
-    fs4.rmSync(staging, { recursive: true, force: true });
+    fs5.rmSync(staging, { recursive: true, force: true });
   }
 }
 function applySwap(target, downloaded) {
@@ -15101,16 +16281,16 @@ function applySwap(target, downloaded) {
   try {
     for (const step of steps) {
       if (step.op === "chmod")
-        fs4.chmodSync(step.from, 493);
+        fs5.chmodSync(step.from, 493);
       else if (step.op === "backup") {
-        fs4.renameSync(step.from, step.to);
+        fs5.renameSync(step.from, step.to);
         backup = step.to;
       } else
-        fs4.renameSync(step.from, step.to);
+        fs5.renameSync(step.from, step.to);
     }
   } catch (err) {
-    if (backup !== undefined && !fs4.existsSync(target))
-      fs4.renameSync(backup, target);
+    if (backup !== undefined && !fs5.existsSync(target))
+      fs5.renameSync(backup, target);
     throw err;
   }
 }
@@ -15183,7 +16363,7 @@ function printSessionTable(sessions) {
     console.log(row.map((cell, col) => cell.padEnd(widths[col])).join("  "));
   }
 }
-var realPath = (target) => fs22.realpathSync.native(target);
+var realPath = (target) => fs25.realpathSync.native(target);
 function scopedHere(sessions) {
   return sessionsInScope(sessions, process.cwd(), realPath);
 }
@@ -15196,7 +16376,7 @@ var help = () => t("cli.help");
 function readDotEnv(file = ".env") {
   const out = {};
   try {
-    for (const line of fs22.readFileSync(file, "utf8").split(/\r?\n/)) {
+    for (const line of fs25.readFileSync(file, "utf8").split(/\r?\n/)) {
       const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m)
         out[m[1]] = m[2].trim();
@@ -15207,7 +16387,7 @@ function readDotEnv(file = ".env") {
 function configuredLocale() {
   try {
     const file = resolvePaths(currentPathEnv()).configFile;
-    const raw = JSON.parse(fs22.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs25.readFileSync(file, "utf8"));
     return typeof raw.locale === "string" ? raw.locale : undefined;
   } catch {
     return;
@@ -15228,6 +16408,11 @@ async function main2() {
     runMcpServer();
     return;
   }
+  if (isPtyHostInvocation(argv)) {
+    const { runPtyHostProcess: runPtyHostProcess2 } = await Promise.resolve().then(() => (init_pty_host_main(), exports_pty_host_main));
+    await runPtyHostProcess2();
+    return;
+  }
   const [command, ...rest] = argv;
   setLocale(resolveLocale({ configured: configuredLocale(), env: process.env }));
   const { flags, positional, passthrough } = parseArgs(rest);
@@ -15258,6 +16443,7 @@ async function main2() {
         const commandOverride = typeof flags.get("cmd") === "string" ? flags.get("cmd").split(/\s+/).filter(Boolean) : undefined;
         const info = await client.call("session.create", {
           cwd: flags.get("cwd") ?? process.cwd(),
+          preferConversationCwd: flags.get("cwd") === undefined,
           name: flags.get("name"),
           shell: flags.get("shell"),
           agent: flags.get("agent"),
@@ -15351,9 +16537,17 @@ async function main2() {
         const [id, indexArg] = positional;
         if (!id || indexArg === undefined)
           throw new Error(t("cli.usage.choose"));
-        const keys2 = buildMenuSelectKeys(Number(indexArg));
-        await client.call("terminal.write", { id, dataB64: Buffer.from(keys2, "utf8").toString("base64") });
+        const index = Number(indexArg);
+        const answered = await client.call("session.choose", { id, index }).catch(async (err) => {
+          if (!/unknown method/i.test(String(err)))
+            throw err;
+          const keys2 = buildMenuSelectKeys(index);
+          await client.call("terminal.write", { id, dataB64: Buffer.from(keys2, "utf8").toString("base64") });
+          return { answered: "menu" };
+        });
         console.log(t("cli.session.selected", { index: indexArg }));
+        if (answered.answered === "onboarding")
+          console.log(t("cli.session.selectedDialog"));
         break;
       }
       case "setup": {
@@ -15429,8 +16623,8 @@ async function main2() {
       case "project": {
         const sub = positional[0] ?? "list";
         if (sub === "add") {
-          const dir = positional[1] ? path21.resolve(positional[1]) : process.cwd();
-          const alias = positional[2] ?? path21.basename(dir);
+          const dir = positional[1] ? path23.resolve(positional[1]) : process.cwd();
+          const alias = positional[2] ?? path23.basename(dir);
           const projects = await client.call("project.add", {
             alias,
             path: dir