@layorixinc/axterm 0.6.0 → 0.6.1

package/dist/cli.js

@@ -46,6 +46,15 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/core/src/menu-keys.ts
+function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
+  if (!Number.isInteger(index) || index < 0) {
+    throw new RangeError(`menu index must be a non-negative integer, got ${index}`);
+  }
+  return MENU_UP.repeat(normalizePresses) + MENU_DOWN.repeat(index) + MENU_SELECT;
+}
+var MENU_UP = "\x1B[A", MENU_DOWN = "\x1B[B", MENU_SELECT = "\r", MENU_NORMALIZE_PRESSES = 24;
+
 // packages/core/src/agent-registry.ts
 function agentProfile(id) {
   const known = PROFILES[id];
@@ -62,6 +71,13 @@ function agentProfile(id) {
     hostHookSource: id
   };
 }
+function menuChoiceKeys(profile, optionIndex) {
+  const keys = profile.approvalKeys;
+  if (keys !== undefined) {
+    return optionIndex === 0 ? keys.allow : optionIndex === 1 ? keys.deny : undefined;
+  }
+  return profile.clampingApprovalMenu === true ? buildMenuSelectKeys(optionIndex) : undefined;
+}
 function renderAgentTitle(profile, state, frame) {
   if (state === undefined)
     return;
@@ -87,8 +103,15 @@ var init_agent_registry = __esm(() => {
     omp: {
       id: "omp",
       displayName: "OMP",
-      title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
+      title: {
+        workingLabel: "OMP",
+        permissionLabel: "OMP - action required",
+        idleLabel: "OMP ready",
+        synthesizeWorking: false,
+        synthesizeTerminal: false
+      },
       hostHookSource: "omp",
+      clampingApprovalMenu: true,
       approvalBypassArgs: ["--approval-mode", "yolo"],
       quota: "gauge",
       resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
@@ -158,6 +181,8 @@ var init_agent_registry = __esm(() => {
       hostHookSource: "claude",
       quota: "event",
       approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
+      approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
+      structuredApprovals: true,
       resume: { argv: ["--resume", "{ref}"], ref: "sessionId", selfNamed: "uuid" }
     },
     gemini: {
@@ -1011,6 +1036,7 @@ usage:
   axterm rm <id\u2026> [--force]        forget a session: its row, scrollback and topic binding
   axterm rm --exited [--all]        forget every exited session this listing would show
   axterm daemon status|stop
+  axterm service install|status|uninstall   start at login and restart daemon failures
   axterm project add <dir> [alias] | list | rm <alias>   register a project for channel use
   axterm run [--worktree BRANCH] [--base REF] ...   worktree-backed session
   axterm fanout --count 3 [--prefix try] "prompt"
@@ -1039,6 +1065,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.session.sentKey": "sent {key}",
     "cli.session.selected": "selected option {index}",
     "cli.session.selectedDialog": "answered the agent's first-run dialog",
+    "cli.choose.daemonTooOld": "this daemon is too old to answer a dialog safely \u2014 its `choose` sent keystrokes that land on the row below on claude and gemini, which is a wider grant. Restart the daemon, or send the keys yourself with `axterm key`",
     "cli.resume.done": "resumed session {id} ({command})",
     "cli.update.current": "axterm {version} is the latest version",
     "cli.update.available": "axterm {latest} is available (you have {current})",
@@ -1082,6 +1109,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.usage.worktree": "usage: axterm worktree list|rm <branch> [--force]",
     "cli.usage.worktreeRm": "usage: axterm worktree rm <branch> [--force]",
     "cli.usage.daemon": "usage: axterm daemon status|stop",
+    "cli.usage.service": "usage: axterm service install|status|uninstall",
     "cli.usage.telegram": "usage: axterm telegram link|doctor|status|discover",
     "cli.usage.fanout": "usage: axterm fanout --count N <prompt>",
     "cli.config.set": "set {path}",
@@ -1098,6 +1126,13 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.worktree.refused": "refused: {reason}",
     "cli.daemon.stopping": "daemon stopping",
     "cli.daemon.notReady": "daemon did not become ready within 15s (see {log})",
+    "cli.service.installed": "installed {kind} service; the daemon is running under the supervisor",
+    "cli.service.uninstalled": "removed service registration; the current daemon keeps running",
+    "cli.service.status": "service: {kind}; installed={installed}; active={active}",
+    "cli.service.yes": "yes",
+    "cli.service.no": "no",
+    "cli.service.commandFailed": "service command failed ({command}): {error}",
+    "cli.service.notReady": "the service started but the daemon was not ready within 15s",
     "cli.telegram.missingSettings": "telegram link: no token/group/user found. Provide --token/--group/--user flags, TELEGRAM_* environment variables, or a .env file in the current directory.",
     "cli.telegram.discoverHint": "Create a group with Topics enabled, add your bot to it, then run this again. Being added is enough \u2014 you do not have to send anything.",
     "cli.telegram.discoverNone": "the bot cannot see any group yet.",
@@ -1128,6 +1163,8 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.status.inferred": "\u2139\uFE0F Guessed from what is running under the shell \u2014 this agent reports nothing, so there are no approval buttons or replies here (axterm attach shows everything).",
     "tg.session.emptyScreen": "(empty screen)",
     "tg.prompt.confirm": "the session is waiting on a confirmation:",
+    "tg.poll.conflict": "\u26A0\uFE0F {machine} cannot receive messages: another axterm is polling this bot token, and Telegram allows only one. Stop the other instance, or give this machine its own bot.",
+    "tg.poll.failed": "\u26A0\uFE0F {machine} cannot receive messages right now: {reason}",
     "tg.prompt.secretAsk": "the session is asking for a secret. Reply with it and the message will be deleted:",
     "tg.prompt.secretDisabled": "the session is waiting for a password. Answering from chat is off (channels.telegram.secretPrompts); attach and type it, or use an SSH key",
     "tg.prompt.secretSubmitted": "the secret reached the session",
@@ -1177,6 +1214,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.answer.pickAtLeastOne": "pick at least one",
     "tg.answer.confirmed": "confirmed",
     "tg.answer.unknownOption": "no such option",
+    "tg.answer.noSafeKey": "axterm cannot press this row safely \u2014 use /key or /type",
     "tg.answer.picked": "{label} selected",
     "tg.answer.toggledOn": "{label} selected",
     "tg.answer.toggledOff": "{label} cleared",
@@ -1225,6 +1263,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.codex.trustStale": "codex hooks: {stale}/{total} trust hashes stale \u2014 codex reports them Modified and silently skips them; re-grant via /hooks in the codex TUI",
     "doctor.codex.trustPending": "codex hooks: {pending}/{total} not yet granted \u2014 appended at the next codex launch",
     "doctor.telegram.ok": "telegram: connected",
+    "doctor.telegram.pollFailing": "telegram cannot receive: {reason}",
     "doctor.telegram.off": "telegram: not running",
     "doctor.telegram.problems": "telegram: {problems}",
     "quota.gauge": "{agent}: {percent}% of {window} used, resets in {resets}",
@@ -1250,11 +1289,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.session.dialogOpen": "session {id} is waiting on a dialog ({state}); answer it with the buttons or /esc first",
     "err.agent.notInstalled": "the agent command '{command}' was not found on PATH \u2014 install it, or pass --cmd to run something else",
     "err.agent.unknown": "unknown agent '{agent}' \u2014 supported: {supported}",
+    "err.choose.noSafeKey": "axterm cannot select row {index} of a {agent} dialog: its menu wraps, so an absolute row cannot be addressed from an unknown cursor position \u2014 use `axterm key` for the keys you want",
     "err.staging.dir": "could not create the session's staging directory {dir} ({error}) \u2014 fix the permissions, or set defaults.staging to runtime",
     "err.staging.notIgnored": "git can see inside {dir}, so a staged file would show up in `git add -A` \u2014 let axterm write its own {file}, or set defaults.staging to runtime",
     "err.claude.conversationBusy": "session {session} is already in conversation {id} \u2014 two sessions writing one transcript would corrupt it; kill that one first",
     "err.claude.noConversation": "claude has no conversation {id} in its store on this machine \u2014 a conversation lives on the machine it ran on, so this one cannot be resumed here",
-    "codex.approval.denied": "Denied from the axterm channel",
+    "agent.approval.denied": "Denied from the axterm channel",
     "err.codex.noAuth": "codex is not logged in ({authFile} not found) \u2014 run `codex login` once, then start the session again",
     "err.codex.authLink": "could not link codex credentials into axterm's CODEX_HOME ({reason}) \u2014 refusing to start a logged-out agent",
     "health.config.invalid": "the configuration file could not be understood",
@@ -1317,6 +1357,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
   axterm rm <id\u2026> [--force]        \uC138\uC158\uC744 \uC78A\uB294\uB2E4: \uBAA9\uB85D\xB7\uC2A4\uD06C\uB864\uBC31\xB7\uD1A0\uD53D \uC5F0\uACB0\uAE4C\uC9C0
   axterm rm --exited [--all]        \uC774 \uBAA9\uB85D\uC5D0 \uBCF4\uC774\uB294 \uC885\uB8CC\uB41C \uC138\uC158\uC744 \uBAA8\uB450 \uC78A\uB294\uB2E4
   axterm daemon status|stop
+  axterm service install|status|uninstall   \uB85C\uADF8\uC778 \uC2DC \uC2DC\uC791\uD558\uACE0 \uB370\uBAAC \uC2E4\uD328 \uC2DC \uC7AC\uC2DC\uC791
   axterm project add <\uD3F4\uB354> [\uBCC4\uCE6D] | list | rm <\uBCC4\uCE6D>   \uCC44\uB110\uC5D0\uC11C \uC4F8 \uD504\uB85C\uC81D\uD2B8 \uB4F1\uB85D
   axterm run [--worktree \uBE0C\uB79C\uCE58] [--base REF] ...   worktree \uAE30\uBC18 \uC138\uC158
   axterm fanout --count 3 [--prefix try] "\uD504\uB86C\uD504\uD2B8"
@@ -1345,6 +1386,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.session.sentKey": "{key} \uC804\uB2EC\uB428",
     "cli.session.selected": "{index}\uBC88 \uD56D\uBAA9 \uC120\uD0DD\uB428",
     "cli.session.selectedDialog": "\uC5D0\uC774\uC804\uD2B8\uC758 \uCCAB \uC2E4\uD589 \uB300\uD654\uC0C1\uC790\uC5D0 \uC751\uB2F5\uD588\uC2B5\uB2C8\uB2E4",
+    "cli.choose.daemonTooOld": "\uC774 \uB370\uBAAC\uC740 \uB300\uD654\uC0C1\uC790\uB97C \uC548\uC804\uD558\uAC8C \uC751\uB2F5\uD560 \uC218 \uC5C6\uB294 \uAD6C\uBC84\uC804\uC785\uB2C8\uB2E4. \uC608\uC804 `choose` \uB294 claude \uC640 gemini \uC5D0\uC11C \uD55C \uD589 \uC544\uB798\uB97C \uC120\uD0DD\uD588\uACE0 \uADF8\uAC83\uC740 \uB354 \uB113\uC740 \uC2B9\uC778\uC785\uB2C8\uB2E4. \uB370\uBAAC\uC744 \uC7AC\uC2DC\uC791\uD558\uAC70\uB098 `axterm key` \uB85C \uC9C1\uC811 \uD0A4\uB97C \uBCF4\uB0B4\uC138\uC694",
     "cli.resume.done": "\uC138\uC158 {id} \uC7AC\uAC1C\uB428 ({command})",
     "cli.update.current": "axterm {version} \uC774 \uCD5C\uC2E0 \uBC84\uC804\uC785\uB2C8\uB2E4",
     "cli.update.available": "axterm {latest} \uC744(\uB97C) \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4 (\uD604\uC7AC {current})",
@@ -1388,6 +1430,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.usage.worktree": "\uC0AC\uC6A9\uBC95: axterm worktree list|rm <\uBE0C\uB79C\uCE58> [--force]",
     "cli.usage.worktreeRm": "\uC0AC\uC6A9\uBC95: axterm worktree rm <\uBE0C\uB79C\uCE58> [--force]",
     "cli.usage.daemon": "\uC0AC\uC6A9\uBC95: axterm daemon status|stop",
+    "cli.usage.service": "\uC0AC\uC6A9\uBC95: axterm service install|status|uninstall",
     "cli.usage.telegram": "\uC0AC\uC6A9\uBC95: axterm telegram link|doctor|status|discover",
     "cli.usage.fanout": "\uC0AC\uC6A9\uBC95: axterm fanout --count N <\uD504\uB86C\uD504\uD2B8>",
     "cli.config.set": "{path} \uC124\uC815\uB428",
@@ -1404,6 +1447,13 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.worktree.refused": "\uAC70\uBD80\uB428: {reason}",
     "cli.daemon.stopping": "\uB370\uBAAC \uC885\uB8CC \uC911",
     "cli.daemon.notReady": "15\uCD08 \uC548\uC5D0 \uB370\uBAAC\uC774 \uC900\uBE44\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4 ({log} \uD655\uC778)",
+    "cli.service.installed": "{kind} \uC11C\uBE44\uC2A4 \uC124\uCE58\uB428. \uB370\uBAAC\uC740 supervisor \uC544\uB798\uC5D0\uC11C \uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4",
+    "cli.service.uninstalled": "\uC11C\uBE44\uC2A4 \uB4F1\uB85D\uC744 \uC81C\uAC70\uD588\uC2B5\uB2C8\uB2E4. \uD604\uC7AC \uB370\uBAAC\uC740 \uACC4\uC18D \uC2E4\uD589\uB429\uB2C8\uB2E4",
+    "cli.service.status": "\uC11C\uBE44\uC2A4: {kind}; \uC124\uCE58={installed}; \uD65C\uC131={active}",
+    "cli.service.yes": "\uC608",
+    "cli.service.no": "\uC544\uB2C8\uC694",
+    "cli.service.commandFailed": "\uC11C\uBE44\uC2A4 \uBA85\uB839 \uC2E4\uD328 ({command}): {error}",
+    "cli.service.notReady": "\uC11C\uBE44\uC2A4\uAC00 \uC2DC\uC791\uB410\uC9C0\uB9CC 15\uCD08 \uC548\uC5D0 \uB370\uBAAC\uC774 \uC900\uBE44\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4",
     "cli.telegram.missingSettings": "telegram link: \uD1A0\uD070/\uADF8\uB8F9/\uC0AC\uC6A9\uC790 \uC815\uBCF4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. --token/--group/--user \uD50C\uB798\uADF8, TELEGRAM_* \uD658\uACBD\uBCC0\uC218, \uB610\uB294 \uD604\uC7AC \uD3F4\uB354\uC758 .env \uD30C\uC77C \uC911 \uD558\uB098\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.",
     "tg.help.general.header": "axterm \uBA85\uB839 (General \uD1A0\uD53D):",
     "tg.help.general.projects": "/projects \u2014 \uB4F1\uB85D\uB41C \uD504\uB85C\uC81D\uD2B8",
@@ -1434,6 +1484,8 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.status.inferred": "\u2139\uFE0F \uC178\uC5D0\uC11C \uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4\uB85C \uCD94\uC815\uD55C \uC0C1\uD0DC\uC785\uB2C8\uB2E4 \u2014 \uC774 \uC5D0\uC774\uC804\uD2B8\uB294 \uC0C1\uD0DC\uB97C \uBCF4\uACE0\uD558\uC9C0 \uC54A\uC544 \uC2B9\uC778 \uBC84\uD2BC\uB3C4, \uB2F5\uBCC0\uB3C4 \uC5C6\uC2B5\uB2C8\uB2E4 (\uC804\uCCB4\uB294 axterm attach\uB85C \uD655\uC778\uD558\uC138\uC694).",
     "tg.session.emptyScreen": "(\uBE48 \uD654\uBA74)",
     "tg.prompt.confirm": "\uC138\uC158\uC774 \uD655\uC778\uC744 \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4:",
+    "tg.poll.conflict": "\u26A0\uFE0F {machine} \uC774 \uBA54\uC2DC\uC9C0\uB97C \uBC1B\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: \uB2E4\uB978 axterm \uC774 \uC774 \uBD07 \uD1A0\uD070\uC744 \uD3F4\uB9C1\uD558\uACE0 \uC788\uACE0 Telegram \uC740 \uD558\uB098\uB9CC \uD5C8\uC6A9\uD569\uB2C8\uB2E4. \uB2E4\uB978 \uC778\uC2A4\uD134\uC2A4\uB97C \uB044\uAC70\uB098 \uC774 \uBA38\uC2E0\uC5D0 \uC804\uC6A9 \uBD07\uC744 \uC8FC\uC138\uC694.",
+    "tg.poll.failed": "\u26A0\uFE0F {machine} \uC774 \uC9C0\uAE08 \uBA54\uC2DC\uC9C0\uB97C \uBC1B\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: {reason}",
     "tg.prompt.secretAsk": "\uC138\uC158\uC774 \uBE44\uBC00\uAC12\uC744 \uC694\uAD6C\uD569\uB2C8\uB2E4. \uB2F5\uC7A5\uD558\uBA74 \uADF8 \uBA54\uC2DC\uC9C0\uB294 \uC0AD\uC81C\uB429\uB2C8\uB2E4:",
     "tg.prompt.secretDisabled": "\uC138\uC158\uC774 \uBE44\uBC00\uBC88\uD638\uB97C \uAE30\uB2E4\uB9AC\uACE0 \uC788\uC2B5\uB2C8\uB2E4. \uCC44\uD305 \uC785\uB825\uC740 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4 (channels.telegram.secretPrompts). attach \uD574\uC11C \uC785\uB825\uD558\uAC70\uB098 SSH \uD0A4\uB97C \uC4F0\uC138\uC694",
     "tg.prompt.secretSubmitted": "\uBE44\uBC00\uAC12\uC774 \uC138\uC158\uC5D0 \uC804\uB2EC\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
@@ -1483,6 +1535,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.answer.pickAtLeastOne": "\uCD5C\uC18C 1\uAC1C\uB294 \uC120\uD0DD\uD558\uC138\uC694",
     "tg.answer.confirmed": "\uD655\uC815\uB428",
     "tg.answer.unknownOption": "\uC5C6\uB294 \uC120\uD0DD\uC9C0",
+    "tg.answer.noSafeKey": "\uC774 \uD589\uC740 \uC548\uC804\uD558\uAC8C \uB204\uB97C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 /key \uB610\uB294 /type\uC744 \uC4F0\uC138\uC694",
     "tg.answer.picked": "{label} \uC120\uD0DD\uB428",
     "tg.answer.toggledOn": "{label} \uC120\uD0DD",
     "tg.answer.toggledOff": "{label} \uD574\uC81C",
@@ -1531,6 +1584,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.codex.trustStale": "codex \uD6C5: {stale}/{total} \uC2E0\uB8B0 \uD574\uC2DC \uBD88\uC77C\uCE58 \u2014 codex\uAC00 Modified\uB85C \uBCF4\uACE0\uD558\uACE0 \uC870\uC6A9\uD788 \uAC74\uB108\uB701\uB2C8\uB2E4; codex TUI\uC758 /hooks\uC5D0\uC11C \uC7AC\uC2B9\uC778\uD558\uC138\uC694",
     "doctor.codex.trustPending": "codex \uD6C5: {pending}/{total} \uBBF8\uC2B9\uC778 \u2014 \uB2E4\uC74C codex \uC2E4\uD589 \uC2DC \uAE30\uB85D\uB429\uB2C8\uB2E4",
     "doctor.telegram.ok": "\uD154\uB808\uADF8\uB7A8: \uC5F0\uACB0\uB428",
+    "doctor.telegram.pollFailing": "\uD154\uB808\uADF8\uB7A8 \uC218\uC2E0 \uBD88\uAC00: {reason}",
     "doctor.telegram.off": "\uD154\uB808\uADF8\uB7A8: \uBBF8\uC2E4\uD589",
     "doctor.telegram.problems": "\uD154\uB808\uADF8\uB7A8: {problems}",
     "quota.gauge": "{agent}: {window} \uD55C\uB3C4\uC758 {percent}% \uC0AC\uC6A9, {resets} \uD6C4 \uCD08\uAE30\uD654",
@@ -1556,11 +1610,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "err.session.dialogOpen": "\uC138\uC158 {id} \uC774(\uAC00) \uB2E4\uC774\uC5BC\uB85C\uADF8\uB97C \uAE30\uB2E4\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4 ({state}). \uBC84\uD2BC\uC73C\uB85C \uB2F5\uD558\uAC70\uB098 /esc \uB97C \uBA3C\uC800 \uBCF4\uB0B4\uC138\uC694",
     "err.agent.notInstalled": "\uC5D0\uC774\uC804\uD2B8 \uBA85\uB839 '{command}' \uC744(\uB97C) PATH \uC5D0\uC11C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC124\uCE58\uD558\uAC70\uB098 --cmd \uB85C \uB2E4\uB978 \uBA85\uB839\uC744 \uC9C0\uC815\uD558\uC138\uC694",
     "err.agent.unknown": "\uC54C \uC218 \uC5C6\uB294 \uC5D0\uC774\uC804\uD2B8 '{agent}' \uC785\uB2C8\uB2E4. \uC9C0\uC6D0: {supported}",
+    "err.choose.noSafeKey": "{agent} \uB300\uD654\uC0C1\uC790\uC758 {index}\uBC88 \uD589\uC740 \uC120\uD0DD\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA54\uB274\uAC00 \uC21C\uD658\uD558\uBBC0\uB85C \uCEE4\uC11C \uC704\uCE58\uB97C \uBAA8\uB974\uB294 \uC0C1\uD0DC\uC5D0\uC11C \uC808\uB300 \uD589\uC744 \uC9C0\uC815\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC6D0\uD558\uB294 \uD0A4\uB294 `axterm key`\uB85C \uBCF4\uB0B4\uC138\uC694",
     "err.staging.dir": "\uC138\uC158\uC758 \uC2A4\uD14C\uC774\uC9D5 \uB514\uB809\uD130\uB9AC {dir} \uC744(\uB97C) \uB9CC\uB4E4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 ({error}). \uAD8C\uD55C\uC744 \uACE0\uCE58\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
     "err.staging.notIgnored": "git\uC774 {dir} \uC548\uC744 \uBCFC \uC218 \uC788\uC5B4\uC11C, \uC2A4\uD14C\uC774\uC9D5\uD55C \uD30C\uC77C\uC774 `git add -A` \uC5D0 \uC7A1\uD799\uB2C8\uB2E4. axterm\uC774 \uC790\uCCB4 {file} \uC744(\uB97C) \uC4F0\uAC8C \uD558\uAC70\uB098 defaults.staging \uC744 runtime \uC73C\uB85C \uC124\uC815\uD558\uC138\uC694",
     "err.claude.conversationBusy": "\uC138\uC158 {session} \uC774(\uAC00) \uC774\uBBF8 \uB300\uD654 {id} \uC5D0 \uB4E4\uC5B4\uAC00 \uC788\uC2B5\uB2C8\uB2E4. \uD55C transcript\uC5D0 \uB450 \uC138\uC158\uC774 \uC4F0\uBA74 \uC190\uC0C1\uB418\uBBC0\uB85C \uBA3C\uC800 \uADF8 \uC138\uC158\uC744 \uC885\uB8CC\uD558\uC138\uC694",
     "err.claude.noConversation": "\uC774 \uBA38\uC2E0\uC758 claude \uC800\uC7A5\uC18C\uC5D0 \uB300\uD654 {id} \uC774(\uAC00) \uC5C6\uC2B5\uB2C8\uB2E4. \uB300\uD654\uB294 \uC2E4\uD589\uB41C \uBA38\uC2E0\uC5D0 \uB0A8\uC73C\uBBC0\uB85C \uC5EC\uAE30\uC11C\uB294 \uC774\uC5B4\uAC08 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
-    "codex.approval.denied": "axterm \uCC44\uB110\uC5D0\uC11C \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+    "agent.approval.denied": "axterm \uCC44\uB110\uC5D0\uC11C \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
     "err.codex.noAuth": "codex\uC5D0 \uB85C\uADF8\uC778\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 ({authFile} \uC5C6\uC74C). `codex login` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD55C \uB4A4 \uC138\uC158\uC744 \uB2E4\uC2DC \uC2DC\uC791\uD558\uC138\uC694",
     "err.codex.authLink": "codex \uC790\uACA9 \uC99D\uBA85\uC744 axterm\uC758 CODEX_HOME\uC5D0 \uC5F0\uACB0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 ({reason}). \uB85C\uADF8\uC544\uC6C3 \uC0C1\uD0DC\uC758 \uC5D0\uC774\uC804\uD2B8\uB294 \uC2DC\uC791\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
     "health.config.invalid": "\uC124\uC815 \uD30C\uC77C\uC744 \uC774\uD574\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
@@ -1864,6 +1919,222 @@ var init_self_spawn = __esm(() => {
   RUNTIME_NAMES = new Set(["bun", "bun.exe", "bun-debug", "bun-debug.exe", "node", "node.exe"]);
 });
 
+// packages/core/src/service.ts
+import path2 from "path";
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdArgument(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("%", "%%")}"`;
+}
+function windowsArgument(value) {
+  if (value !== "" && !/[\s"]/u.test(value))
+    return value;
+  let out = '"';
+  let slashes = 0;
+  for (const char of value) {
+    if (char === "\\") {
+      slashes++;
+      continue;
+    }
+    if (char === '"') {
+      out += "\\".repeat(slashes * 2 + 1) + '"';
+      slashes = 0;
+      continue;
+    }
+    out += "\\".repeat(slashes) + char;
+    slashes = 0;
+  }
+  return out + "\\".repeat(slashes * 2) + '"';
+}
+function windowsCommandLine(args) {
+  return args.map(windowsArgument).join(" ");
+}
+function environmentEntries(input) {
+  return Object.entries(input.environment ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key))
+      throw new Error(`invalid service environment key: ${key}`);
+    if (/[\0\r\n]/u.test(value))
+      throw new Error(`invalid service environment value for ${key}`);
+    return [key, value];
+  });
+}
+function systemdEnvironment(input) {
+  return environmentEntries(input).map(([key, value]) => `Environment="${`${key}=${value}`.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("%", "%%")}"`).join(`
+`);
+}
+function launchdEnvironment(input) {
+  const entries = environmentEntries(input);
+  if (entries.length === 0)
+    return "";
+  return `  <key>EnvironmentVariables</key>
+  <dict>
+${entries.map(([key, value]) => `    <key>${xml(key)}</key>
+    <string>${xml(value)}</string>`).join(`
+`)}
+  </dict>
+`;
+}
+function systemdDefinition(input) {
+  const argv = [input.launch.command, ...input.launch.args].map(systemdArgument).join(" ");
+  const environment = systemdEnvironment(input);
+  return {
+    kind: "systemd",
+    id: SYSTEMD_SERVICE,
+    file: path2.posix.join(input.homeDir, ".config/systemd/user", SYSTEMD_SERVICE),
+    contents: `[Unit]
+Description=axterm daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=:${argv}
+${environment ? `${environment}
+` : ""}Restart=on-failure
+RestartSec=2
+TimeoutStopSec=20
+# The PTY host is detached but remains in this cgroup. Stop only the daemon.
+KillMode=process
+
+[Install]
+WantedBy=default.target
+`
+  };
+}
+function launchdDefinition(input) {
+  const argumentsXml = [input.launch.command, ...input.launch.args].map((arg) => `    <string>${xml(arg)}</string>`).join(`
+`);
+  const logFile = path2.posix.join(input.stateDir, "logs/service.log");
+  return {
+    kind: "launchd",
+    id: LAUNCHD_LABEL,
+    file: path2.posix.join(input.homeDir, "Library/LaunchAgents", `${LAUNCHD_LABEL}.plist`),
+    contents: `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argumentsXml}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xml(input.homeDir)}</string>
+${launchdEnvironment(input)}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>2</integer>
+  <key>AbandonProcessGroup</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(logFile)}</string>
+</dict>
+</plist>
+`
+  };
+}
+function powershellLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function taskDefinition(input) {
+  if (!input.userId)
+    throw new Error("Task Scheduler requires userId");
+  const entries = environmentEntries(input);
+  let command = input.launch.command;
+  let argumentsLine = windowsCommandLine(input.launch.args);
+  let companionFiles;
+  if (entries.length > 0) {
+    const wrapperFile = path2.win32.join(input.stateDir, "service", "axterm-service.ps1");
+    const environment = entries.map(([key, value]) => `$env:${key} = ${powershellLiteral(value)}`).join(`\r
+`);
+    const invocation = [input.launch.command, ...input.launch.args].map(powershellLiteral).join(" ");
+    companionFiles = [
+      {
+        file: wrapperFile,
+        contents: `$ErrorActionPreference = 'Stop'\r
+${environment}\r
+& ${invocation}\r
+exit $LASTEXITCODE\r
+`
+      }
+    ];
+    command = "powershell.exe";
+    argumentsLine = windowsCommandLine([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      wrapperFile
+    ]);
+  }
+  return {
+    kind: "task-scheduler",
+    id: WINDOWS_TASK,
+    file: path2.win32.join(input.stateDir, "service", "axterm-task.xml"),
+    contents: `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>axterm daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xml(input.userId)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xml(input.userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>false</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>255</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xml(command)}</Command>
+      <Arguments>${xml(argumentsLine)}</Arguments>
+      <WorkingDirectory>${xml(input.homeDir)}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+`,
+    ...companionFiles ? { companionFiles } : {}
+  };
+}
+function serviceDefinition(input) {
+  if (input.platform === "linux")
+    return systemdDefinition(input);
+  if (input.platform === "darwin")
+    return launchdDefinition(input);
+  if (input.platform === "win32")
+    return taskDefinition(input);
+  throw new Error(`service management is not supported on ${input.platform}`);
+}
+var SYSTEMD_SERVICE = "axterm.service", LAUNCHD_LABEL = "com.layorix.axterm.daemon", WINDOWS_TASK = "axterm-daemon";
+var init_service = () => {};
+
 // packages/core/src/attachment.ts
 function megabytes(bytes) {
   return `${Math.round(bytes / (1024 * 1024))} MB`;
@@ -2054,6 +2325,22 @@ function parseProjectRef(raw) {
     return { machine: text.slice(0, split), alias: text.slice(split + 1) };
   return { alias: text };
 }
+function parseCommandAddress(token) {
+  const at = token.indexOf("@");
+  if (at < 0)
+    return { command: token };
+  const target = token.slice(at + 1);
+  if (!/^[A-Za-z0-9_]+$/.test(target))
+    return { command: token };
+  return { command: token.slice(0, at), target };
+}
+function commandIsForBot(target, self) {
+  if (target === undefined)
+    return true;
+  if (self === undefined)
+    return false;
+  return target.toLowerCase() === self.toLowerCase();
+}
 var MAX_NAME_LENGTH = 32;
 
 // packages/core/src/fanout.ts
@@ -2163,6 +2450,9 @@ function buildApprovalQuestion(toolName) {
 function isModalState(state) {
   return state === "blocked" || state === "waiting";
 }
+function offersKeystrokeApproval(profile, state) {
+  return state === "blocked" && profile.structuredApprovals !== true;
+}
 function dialogTransition(nextState, dialogOpen) {
   if (isModalState(nextState))
     return { open: true, resolved: false };
@@ -2173,15 +2463,6 @@ function isPromptInjectable(state) {
 }
 var init_choice = () => {};
 
-// packages/core/src/menu-keys.ts
-function buildMenuSelectKeys(index, normalizePresses = MENU_NORMALIZE_PRESSES) {
-  if (!Number.isInteger(index) || index < 0) {
-    throw new RangeError(`menu index must be a non-negative integer, got ${index}`);
-  }
-  return MENU_UP.repeat(normalizePresses) + MENU_DOWN.repeat(index) + MENU_SELECT;
-}
-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)
@@ -2548,7 +2829,7 @@ function mapClaudeHook(input) {
   }
 }
 function buildClaudeSettings(input) {
-  const handler = {
+  const handler = (timeout) => ({
     type: "http",
     url: `http://127.0.0.1:${input.port}/hook/claude`,
     headers: {
@@ -2556,16 +2837,36 @@ function buildClaudeSettings(input) {
       "x-axterm-session": input.sessionId,
       "x-axterm-launch": input.launchToken
     },
-    timeout: HOOK_TIMEOUT_SECONDS
-  };
+    timeout
+  });
+  const observe = handler(HOOK_TIMEOUT_SECONDS);
   const hooks = {};
-  for (const event of TOOL_EVENTS)
-    hooks[event] = [{ matcher: "*", hooks: [handler] }];
+  for (const event of TOOL_EVENTS) {
+    const single = event === "PermissionRequest" ? handler(APPROVAL_TIMEOUT_SECONDS) : observe;
+    hooks[event] = [{ matcher: "*", hooks: [single] }];
+  }
   for (const event of PLAIN_EVENTS)
-    hooks[event] = [{ hooks: [handler] }];
+    hooks[event] = [{ hooks: [observe] }];
   return { hooks };
 }
-var MAX_RESULT_TEXT = 2000, HOOK_TIMEOUT_SECONDS = 5, TOOL_EVENTS, PLAIN_EVENTS;
+function hookPermissionDecision(question, answers, denyMessage) {
+  const picked = answers?.find((a) => a.questionIndex === 0)?.selected[0];
+  if (picked === undefined)
+    return;
+  if (picked === question.options[0]?.label) {
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
+  }
+  if (picked === question.options[1]?.label) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PermissionRequest",
+        decision: { behavior: "deny", ...denyMessage !== undefined ? { message: denyMessage } : {} }
+      }
+    };
+  }
+  return;
+}
+var MAX_RESULT_TEXT = 2000, HOOK_TIMEOUT_SECONDS = 5, APPROVAL_TIMEOUT_SECONDS = 120, APPROVAL_HOLD_MS = 110000, TOOL_EVENTS, PLAIN_EVENTS;
 var init_claude_hooks = __esm(() => {
   TOOL_EVENTS = ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest"];
   PLAIN_EVENTS = [
@@ -2591,18 +2892,25 @@ function detectOnboarding(agent, screen) {
     if (!dialog)
       continue;
     const options = [];
+    let lastOption = -1;
     const end = Math.min(lines.length, i + 1 + OPTION_WINDOW_LINES + 1);
     for (let j = i + 1;j < end; j++) {
       const row = OPTION_ROW.exec(lines[j]);
-      if (row)
+      if (row) {
         options.push({ digit: row[1], label: row[2].trim() });
+        lastOption = j;
+      }
     }
-    if (options.length >= 2)
-      return { kind: dialog.kind, question: dialog.question, options };
+    if (options.length < 2)
+      continue;
+    const noise = lines.slice(lastOption + 1).filter((row) => row !== "" && !DIALOG_FOOTER.test(row));
+    if (noise.length > QUIET_AFTER_OPTIONS)
+      continue;
+    return { kind: dialog.kind, question: dialog.question, options };
   }
   return;
 }
-var DIALOGS, OPTION_ROW, OPTION_WINDOW_LINES = 8;
+var DIALOGS, OPTION_ROW, OPTION_WINDOW_LINES = 8, QUIET_AFTER_OPTIONS = 3, DIALOG_FOOTER;
 var init_onboarding = __esm(() => {
   DIALOGS = {
     gemini: [
@@ -2618,6 +2926,97 @@ var init_onboarding = __esm(() => {
     codex: [{ kind: "folderTrust", question: "Do you trust the contents of this directory?" }]
   };
   OPTION_ROW = /^[\u25CF\u25CB\u276F>\u203A]?\s*(\d)\.\s+(.+)$/;
+  DIALOG_FOOTER = /^[\s\u2502\u2500\u2570\u256F\u256D\u256E\u250C\u2510\u2514\u2518|]*$|enter to (confirm|continue|select)|esc to cancel|use enter to select|press enter|\u2191\/\u2193|arrow keys|tab to|^\(.*\)$/i;
+});
+
+// packages/core/src/diff-view.ts
+function scanStructure(lines) {
+  const meta = new Set;
+  let proven = false;
+  let inHunk = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      proven ||= HUNK_HEADER.test(line);
+      continue;
+    }
+    if (FILE_SECTION_START.test(line)) {
+      inHunk = false;
+      proven ||= line.startsWith("diff --git ");
+      continue;
+    }
+    if (inHunk || !line.startsWith("--- "))
+      continue;
+    if ((lines[i + 1] ?? "").startsWith("+++ ")) {
+      meta.add(i);
+      meta.add(i + 1);
+      i += 1;
+    }
+  }
+  return { meta, proven };
+}
+function countTail(lines) {
+  let added = 0;
+  let removed = 0;
+  for (const line of lines) {
+    if (line.startsWith("+++ ") || line.startsWith("--- "))
+      continue;
+    if (line.startsWith("+"))
+      added += 1;
+    else if (line.startsWith("-"))
+      removed += 1;
+  }
+  return { added, removed };
+}
+function summarizePatch(patch, maxChars = DIFF_MAX_CHARS, maxLines = DIFF_MAX_LINES) {
+  const totalChars = patch.length;
+  if (totalChars === 0)
+    return;
+  const clipped = patch.slice(0, maxChars);
+  const all = clipped.split(`
+`);
+  const cutChars = totalChars > maxChars;
+  const cutLines = all.length > maxLines;
+  const kept = all.slice(0, maxLines);
+  const { meta, proven } = scanStructure(kept);
+  if (!proven)
+    return;
+  let added = 0;
+  let removed = 0;
+  const lines = kept.map((line, i) => {
+    if (meta.has(i) || line.startsWith("@@") || FILE_SECTION_START.test(line)) {
+      return { kind: "meta", text: line };
+    }
+    if (line.startsWith("+")) {
+      added += 1;
+      return { kind: "add", text: line.slice(1) };
+    }
+    if (line.startsWith("-")) {
+      removed += 1;
+      return { kind: "del", text: line.slice(1) };
+    }
+    return { kind: "context", text: line };
+  });
+  if (added + removed === 0)
+    return;
+  const tail = countTail(all.slice(maxLines));
+  added += tail.added;
+  removed += tail.removed;
+  const truncated = cutChars ? "chars" : cutLines ? "lines" : undefined;
+  return {
+    lines: truncated === undefined ? lines : [...lines.slice(0, maxLines - 1), TRUNCATED],
+    added,
+    removed,
+    ...truncated === undefined ? {} : { truncated },
+    totalChars
+  };
+}
+var DIFF_MAX_CHARS = 8000, DIFF_MAX_LINES = 80, TRUNCATED, HUNK_HEADER, FILE_SECTION_START;
+var init_diff_view = __esm(() => {
+  TRUNCATED = { kind: "meta", text: "\u2026 diff truncated \u2026" };
+  HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
+  FILE_SECTION_START = /^(?:diff |index |old mode |new mode |new file mode |deleted file mode |similarity index |dissimilarity index |rename |copy |Binary files )/;
 });
 
 // packages/core/src/doctor.ts
@@ -2863,7 +3262,7 @@ var SEQUENCES, KEY_NAMES;
 var init_keys = __esm(() => {
   SEQUENCES = {
     approve: "\r",
-    deny: "\x1B[B\r",
+    deny: "\x1B",
     enter: "\r",
     esc: "\x1B",
     up: "\x1B[A",
@@ -3339,24 +3738,7 @@ trusted_hash = "${e.hash}"
   }).join(`
 `);
 }
-function codexPermissionDecision(question, answers, denyMessage) {
-  const picked = answers?.find((a) => a.questionIndex === 0)?.selected[0];
-  if (picked === undefined)
-    return;
-  if (picked === question.options[0]?.label) {
-    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
-  }
-  if (picked === question.options[1]?.label) {
-    return {
-      hookSpecificOutput: {
-        hookEventName: "PermissionRequest",
-        decision: { behavior: "deny", ...denyMessage !== undefined ? { message: denyMessage } : {} }
-      }
-    };
-  }
-  return;
-}
-var OBSERVATION_TIMEOUT_SECONDS = 15, CODEX_PERMISSION_TIMEOUT_SECONDS = 120, CODEX_APPROVAL_HOLD_MS = 110000, CODEX_APPROVAL_POST_TIMEOUT_MS = 115000, SESSION_END_TIMEOUT_SECONDS = 2, OBSERVATION_EVENTS, EVENT_KEY_LABELS;
+var OBSERVATION_TIMEOUT_SECONDS = 15, CODEX_PERMISSION_TIMEOUT_SECONDS = 120, CODEX_APPROVAL_POST_TIMEOUT_MS = 115000, SESSION_END_TIMEOUT_SECONDS = 2, OBSERVATION_EVENTS, EVENT_KEY_LABELS;
 var init_codex_hooks = __esm(() => {
   OBSERVATION_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"];
   EVENT_KEY_LABELS = {
@@ -3610,11 +3992,11 @@ var init_prompt_detect = __esm(() => {
 });
 
 // packages/core/src/session-scope.ts
-import path2 from "path";
+import path3 from "path";
 function comparable(target, resolve) {
-  let real = path2.resolve(target);
+  let real = path3.resolve(target);
   try {
-    real = path2.resolve(resolve(real));
+    real = path3.resolve(resolve(real));
   } catch {}
   const trimmed = real.replace(/[\\/]+$/, "");
   return process.platform === "win32" ? trimmed.toLowerCase() : trimmed;
@@ -3622,7 +4004,7 @@ function comparable(target, resolve) {
 function pathWithin(parent, child, resolve = asGiven) {
   const from = comparable(parent, resolve);
   const to = comparable(child, resolve);
-  return to === from || to.startsWith(from + path2.sep);
+  return to === from || to.startsWith(from + path3.sep);
 }
 function sessionInScope(session, scope, resolve = asGiven) {
   if (pathWithin(scope, session.cwd, resolve))
@@ -3677,6 +4059,7 @@ var init_src = __esm(() => {
   init_agent_registry();
   init_agent_resume();
   init_self_spawn();
+  init_service();
   init_channel_spi();
   init_update();
   init_errors();
@@ -3688,6 +4071,7 @@ var init_src = __esm(() => {
   init_pty_protocol();
   init_claude_hooks();
   init_onboarding();
+  init_diff_view();
   init_doctor();
   init_stall();
   init_codex_stream();
@@ -3709,14 +4093,14 @@ var init_src = __esm(() => {
 });
 
 // packages/daemon/src/config-store.ts
-import fs6 from "fs";
-import path6 from "path";
-function writeAtomic(target, contents, mode) {
+import fs7 from "fs";
+import path8 from "path";
+function writeAtomic2(target, contents, mode) {
   const tmp = `${target}.tmp`;
-  fs6.writeFileSync(tmp, contents, { mode });
-  fs6.renameSync(tmp, target);
+  fs7.writeFileSync(tmp, contents, { mode });
+  fs7.renameSync(tmp, target);
   if (process.platform !== "win32")
-    fs6.chmodSync(target, mode);
+    fs7.chmodSync(target, mode);
 }
 
 class ConfigStore {
@@ -3732,16 +4116,16 @@ class ConfigStore {
   }
   load() {
     this.loadError = undefined;
-    fs6.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
+    fs7.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
     if (process.platform !== "win32") {
       try {
-        fs6.chmodSync(this.paths.configDir, DIR_MODE);
+        fs7.chmodSync(this.paths.configDir, DIR_MODE);
       } catch {}
     }
     this.config = structuredClone(DEFAULT_CONFIG);
-    if (fs6.existsSync(this.paths.configFile)) {
+    if (fs7.existsSync(this.paths.configFile)) {
       try {
-        const parsed = parseConfig(JSON.parse(fs6.readFileSync(this.paths.configFile, "utf8")));
+        const parsed = parseConfig(JSON.parse(fs7.readFileSync(this.paths.configFile, "utf8")));
         if ("errors" in parsed)
           this.loadError = parsed.errors.join("; ");
         else
@@ -3751,10 +4135,10 @@ class ConfigStore {
       }
     }
     this.secrets = {};
-    if (fs6.existsSync(this.paths.secretsFile)) {
+    if (fs7.existsSync(this.paths.secretsFile)) {
       this.tightenPermissions(this.paths.secretsFile);
       try {
-        const raw = JSON.parse(fs6.readFileSync(this.paths.secretsFile, "utf8"));
+        const raw = JSON.parse(fs7.readFileSync(this.paths.secretsFile, "utf8"));
         if (raw !== null && typeof raw === "object") {
           for (const [key, value] of Object.entries(raw)) {
             if (typeof value === "string")
@@ -3770,8 +4154,8 @@ class ConfigStore {
     if (process.platform === "win32")
       return;
     try {
-      if ((fs6.statSync(file).mode & 63) !== 0)
-        fs6.chmodSync(file, FILE_MODE);
+      if ((fs7.statSync(file).mode & 63) !== 0)
+        fs7.chmodSync(file, FILE_MODE);
     } catch {}
   }
   get() {
@@ -3779,7 +4163,7 @@ class ConfigStore {
   }
   health() {
     return configHealth({
-      fileExists: fs6.existsSync(this.paths.configFile),
+      fileExists: fs7.existsSync(this.paths.configFile),
       parseError: this.loadError,
       config: this.resolved()
     });
@@ -3812,7 +4196,7 @@ class ConfigStore {
     const parsed = parseConfig(candidate);
     if ("errors" in parsed)
       throw new Error(parsed.errors.join("; "));
-    writeAtomic(this.paths.configFile, `${JSON.stringify(parsed.config, null, 2)}
+    writeAtomic2(this.paths.configFile, `${JSON.stringify(parsed.config, null, 2)}
 `, FILE_MODE);
     this.config = parsed.config;
     this.loadError = undefined;
@@ -3824,11 +4208,11 @@ class ConfigStore {
       delete this.secrets[dottedPath];
     else
       this.secrets[dottedPath] = value;
-    if (!fs6.existsSync(this.paths.configFile)) {
-      writeAtomic(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
+    if (!fs7.existsSync(this.paths.configFile)) {
+      writeAtomic2(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
 `, FILE_MODE);
     }
-    writeAtomic(this.paths.secretsFile, `${JSON.stringify(this.secrets, null, 2)}
+    writeAtomic2(this.paths.secretsFile, `${JSON.stringify(this.secrets, null, 2)}
 `, FILE_MODE);
   }
   hasSecret(dottedPath) {
@@ -3854,7 +4238,7 @@ class ConfigStore {
   fingerprint() {
     const stamp = (file) => {
       try {
-        return String(fs6.statSync(file).mtimeMs);
+        return String(fs7.statSync(file).mtimeMs);
       } catch {
         return "-";
       }
@@ -3876,8 +4260,8 @@ function applyPath(config, dottedPath, value) {
 function defaultConfigStorePaths(configDir) {
   return {
     configDir,
-    configFile: path6.join(configDir, "config.json"),
-    secretsFile: path6.join(configDir, "secrets.json")
+    configFile: path8.join(configDir, "config.json"),
+    secretsFile: path8.join(configDir, "secrets.json")
   };
 }
 var ENV_ALIASES, DIR_MODE = 448, FILE_MODE = 384;
@@ -3896,13 +4280,13 @@ var init_config_store = __esm(() => {
 });
 
 // packages/daemon/src/shell.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 function findExecutable(name, env) {
   const isWindows = env.platform === "win32";
-  const join = isWindows ? path7.win32.join : path7.posix.join;
+  const join = isWindows ? path9.win32.join : path9.posix.join;
   const separator = isWindows ? ";" : ":";
-  const extensions = isWindows ? path7.win32.extname(name).length > 0 ? [""] : env.pathExt.split(";").filter((e) => e.length > 0) : [""];
+  const extensions = isWindows ? path9.win32.extname(name).length > 0 ? [""] : env.pathExt.split(";").filter((e) => e.length > 0) : [""];
   for (const rawDir of env.pathEnv.split(separator)) {
     const dir = rawDir.trim().replace(/^"|"$/g, "");
     if (dir.length === 0)
@@ -3920,16 +4304,16 @@ function lookupOnPath(name) {
     platform: process.platform,
     pathEnv: process.env["PATH"] ?? "",
     pathExt: process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD",
-    exists: (candidate) => fs7.existsSync(candidate)
+    exists: (candidate) => fs8.existsSync(candidate)
   });
 }
 function resolveShell(kind) {
   if (process.platform !== "win32")
     return resolvePosixShell(kind);
   const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
-  const windowsPowershell = path7.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const windowsPowershell = path9.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
   if (kind === "cmd") {
-    return { kind: "cmd", exe: path7.join(systemRoot, "System32", "cmd.exe") };
+    return { kind: "cmd", exe: path9.join(systemRoot, "System32", "cmd.exe") };
   }
   if (kind === "powershell") {
     return { kind: "powershell", exe: windowsPowershell };
@@ -3957,7 +4341,7 @@ function resolvePosixShell(kind) {
       candidates.push({ kind: "bash", exe: login });
     candidates.push({ kind: "bash", exe: "/bin/bash" }, { kind: "bash", exe: "/usr/bin/bash" });
   }
-  const found = candidates.find((c) => fs7.existsSync(c.exe));
+  const found = candidates.find((c) => fs8.existsSync(c.exe));
   if (found)
     return found;
   return { kind: "sh", exe: "/bin/sh" };
@@ -4002,24 +4386,24 @@ function ipcEndpoint(platform, user, env) {
     const suffix = `-${shortHash(env.runtimeDir)}`;
     return `\\\\.\\pipe\\axterm-${safeUser}${suffix}`;
   }
-  return path7.posix.join(env.runtimeDir, "axterm.sock");
+  return path9.posix.join(env.runtimeDir, "axterm.sock");
 }
 var cachedPwsh;
 var init_shell = () => {};
 
 // packages/daemon/src/paths.ts
-import fs8 from "fs";
-import os3 from "os";
-import path8 from "path";
+import fs9 from "fs";
+import os4 from "os";
+import path10 from "path";
 function ensureDataDirs() {
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir, SCROLLBACK_DIR, LOG_DIR, EXT_DIR]) {
-    fs8.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
+    fs9.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
   }
   if (process.platform === "win32")
     return;
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir]) {
     try {
-      fs8.chmodSync(dir, DIR_MODE2);
+      fs9.chmodSync(dir, DIR_MODE2);
     } catch {}
   }
 }
@@ -4027,14 +4411,14 @@ function restrictFile(file) {
   if (process.platform === "win32")
     return;
   try {
-    fs8.chmodSync(file, 384);
+    fs9.chmodSync(file, 384);
   } catch {}
 }
 function log(message) {
   const line = `${new Date().toISOString()} ${message}
 `;
   try {
-    fs8.appendFileSync(LOG_FILE, line);
+    fs9.appendFileSync(LOG_FILE, line);
   } catch {}
 }
 var PATHS, CONFIG_DIR, STATE_DIR, RUNTIME_DIR, SCROLLBACK_DIR, LOG_DIR, EXT_DIR, DB_PATH, RUNTIME_FILE2, HOOK_ENDPOINT_FILE, DIR_MODE2 = 448, PIPE_PATH, LOG_FILE;
@@ -4051,15 +4435,15 @@ var init_paths = __esm(() => {
   DB_PATH = PATHS.dbFile;
   RUNTIME_FILE2 = PATHS.runtimeFile;
   HOOK_ENDPOINT_FILE = PATHS.hookEndpointFile;
-  PIPE_PATH = ipcEndpoint(process.platform, os3.userInfo().username, {
+  PIPE_PATH = ipcEndpoint(process.platform, os4.userInfo().username, {
     runtimeDir: PATHS.runtimeDir
   });
-  LOG_FILE = path8.join(LOG_DIR, "daemon.log");
+  LOG_FILE = path10.join(LOG_DIR, "daemon.log");
 });
 
 // packages/daemon/src/store.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 import { Database } from "bun:sqlite";
 function rowToInfo(row) {
   return {
@@ -4090,7 +4474,7 @@ function rowToInfo(row) {
 class Store {
   db;
   constructor(dbPath = DB_PATH) {
-    fs9.mkdirSync(path9.dirname(dbPath), { recursive: true });
+    fs10.mkdirSync(path11.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath, { strict: true });
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`
@@ -4258,11 +4642,11 @@ var init_store = __esm(() => {
 });
 
 // packages/daemon/src/config-migrate.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import { Database as Database2 } from "bun:sqlite";
 function checkpointWal(dbFile) {
-  if (!fs10.existsSync(dbFile))
+  if (!fs11.existsSync(dbFile))
     return;
   try {
     const db = new Database2(dbFile);
@@ -4272,32 +4656,32 @@ function checkpointWal(dbFile) {
 }
 function relocate(source, target) {
   try {
-    fs10.renameSync(source, target);
+    fs11.renameSync(source, target);
   } catch {
-    fs10.cpSync(source, target, { recursive: true });
+    fs11.cpSync(source, target, { recursive: true });
   }
 }
 function moveInto(from, to, notes) {
-  checkpointWal(path10.join(from, "axterm.db"));
-  fs10.mkdirSync(to, { recursive: true });
+  checkpointWal(path12.join(from, "axterm.db"));
+  fs11.mkdirSync(to, { recursive: true });
   for (const entry of STATE_ENTRIES) {
-    const source = path10.join(from, entry);
-    const target = path10.join(to, entry);
-    if (!fs10.existsSync(source))
+    const source = path12.join(from, entry);
+    const target = path12.join(to, entry);
+    if (!fs11.existsSync(source))
       continue;
-    if (!fs10.existsSync(target)) {
+    if (!fs11.existsSync(target)) {
       relocate(source, target);
       notes.push(`moved ${entry}`);
       continue;
     }
-    if (!fs10.statSync(source).isDirectory() || !fs10.statSync(target).isDirectory())
+    if (!fs11.statSync(source).isDirectory() || !fs11.statSync(target).isDirectory())
       continue;
     let moved = 0;
-    for (const child of fs10.readdirSync(source)) {
-      const childTarget = path10.join(target, child);
-      if (fs10.existsSync(childTarget))
+    for (const child of fs11.readdirSync(source)) {
+      const childTarget = path12.join(target, child);
+      if (fs11.existsSync(childTarget))
         continue;
-      relocate(path10.join(source, child), childTarget);
+      relocate(path12.join(source, child), childTarget);
       moved += 1;
     }
     if (moved > 0)
@@ -4307,29 +4691,29 @@ function moveInto(from, to, notes) {
 function migrateLegacyConfig(input) {
   const notes = [];
   const storePaths = defaultConfigStorePaths(input.configDir);
-  if (fs10.existsSync(storePaths.configFile))
+  if (fs11.existsSync(storePaths.configFile))
     return { migrated: false, notes };
-  const configSource = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "config.json")));
+  const configSource = input.legacyRoots.find((dir) => fs11.existsSync(path12.join(dir, "config.json")));
   if (configSource !== undefined) {
-    fs10.mkdirSync(input.configDir, { recursive: true });
-    fs10.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
-    const secrets = path10.join(configSource, "secrets.json");
-    if (fs10.existsSync(secrets)) {
-      fs10.copyFileSync(secrets, storePaths.secretsFile);
+    fs11.mkdirSync(input.configDir, { recursive: true });
+    fs11.copyFileSync(path12.join(configSource, "config.json"), storePaths.configFile);
+    const secrets = path12.join(configSource, "secrets.json");
+    if (fs11.existsSync(secrets)) {
+      fs11.copyFileSync(secrets, storePaths.secretsFile);
       try {
-        fs10.chmodSync(storePaths.secretsFile, 384);
+        fs11.chmodSync(storePaths.secretsFile, 384);
       } catch {}
     }
-    fs10.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
+    fs11.writeFileSync(path12.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
   ${input.configDir}
 ` + `These files are no longer used. secrets.json still holds your bot token \u2014 delete this directory once you are satisfied.
 `);
     notes.push(`adopted configuration from ${configSource}`);
   }
-  const legacy = input.legacyRoots.find((dir) => fs10.existsSync(path10.join(dir, "axterm.db")));
+  const legacy = input.legacyRoots.find((dir) => fs11.existsSync(path12.join(dir, "axterm.db")));
   if (legacy !== undefined) {
     moveInto(legacy, input.stateDir, notes);
-    fs10.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
+    fs11.writeFileSync(path12.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
   ${input.stateDir}
 and configuration in:
   ${input.configDir}
@@ -4338,8 +4722,8 @@ and configuration in:
   }
   if (configSource !== undefined)
     return { migrated: true, ...legacy ? { from: legacy } : {}, notes };
-  const dbFile = path10.join(input.stateDir, "axterm.db");
-  if (!fs10.existsSync(dbFile))
+  const dbFile = path12.join(input.stateDir, "axterm.db");
+  if (!fs11.existsSync(dbFile))
     return { migrated: notes.length > 0, ...legacy ? { from: legacy } : {}, notes };
   const store = new Store(dbFile);
   const machine2 = store.getConfig("axterm_machine");
@@ -5177,13 +5561,13 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
 var init_axterm_agent_status = () => {};
 
 // packages/daemon/src/ext-install.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path13 from "path";
 function installExtensionAsset(targetDir) {
-  fs11.mkdirSync(targetDir, { recursive: true });
-  const target = path11.join(targetDir, "axterm-agent-status.mjs");
+  fs12.mkdirSync(targetDir, { recursive: true });
+  const target = path13.join(targetDir, "axterm-agent-status.mjs");
   const js = new Bun.Transpiler({ loader: "ts" }).transformSync(extensionSource);
-  fs11.writeFileSync(target, MANAGED_HEADER + js);
+  fs12.writeFileSync(target, MANAGED_HEADER + js);
   return target;
 }
 var extensionSource, MANAGED_HEADER = `// @axterm-managed-omp-extension
@@ -5196,8 +5580,8 @@ var init_ext_install = __esm(() => {
 
 // packages/daemon/src/workspace-local.ts
 import { spawn as spawn2 } from "child_process";
-import fs12 from "fs/promises";
-import path12 from "path";
+import fs13 from "fs/promises";
+import path14 from "path";
 function isAbsent(error) {
   const code = error?.code;
   return code === "ENOENT" || code === "ENOTDIR";
@@ -5210,10 +5594,10 @@ class LocalWorkspace {
     this.stagingDir = stagingDir;
   }
   async list(dir) {
-    const dirents = await fs12.readdir(dir, { withFileTypes: true });
+    const dirents = await fs13.readdir(dir, { withFileTypes: true });
     const stats = await Promise.all(dirents.map(async (dirent) => {
       try {
-        return await fs12.lstat(path12.join(dir, dirent.name));
+        return await fs13.lstat(path14.join(dir, dirent.name));
       } catch (error) {
         if (isAbsent(error))
           return;
@@ -5237,7 +5621,7 @@ class LocalWorkspace {
   }
   async stat(target) {
     try {
-      const stat = await fs12.stat(target);
+      const stat = await fs13.stat(target);
       const kind = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
       return { kind, size: stat.size, mtimeMs: stat.mtimeMs };
     } catch (error) {
@@ -5248,8 +5632,8 @@ class LocalWorkspace {
   }
   async read(file, limit) {
     if (limit === undefined)
-      return await fs12.readFile(file);
-    const handle = await fs12.open(file, "r");
+      return await fs13.readFile(file);
+    const handle = await fs13.open(file, "r");
     try {
       const buffer = Buffer.allocUnsafe(Math.min(limit, (await handle.stat()).size));
       let filled = 0;
@@ -5268,10 +5652,10 @@ class LocalWorkspace {
     return Promise.resolve(file);
   }
   async mkdirp(dir, mode) {
-    await fs12.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
+    await fs13.mkdir(dir, mode === undefined ? { recursive: true } : { recursive: true, mode });
   }
   async write(file, bytes, mode) {
-    await fs12.writeFile(file, bytes, mode === undefined ? undefined : { mode });
+    await fs13.writeFile(file, bytes, mode === undefined ? undefined : { mode });
   }
   exec(argv, cwd) {
     const [command, ...args] = argv;
@@ -5300,9 +5684,9 @@ var init_workspace_local = () => {};
 
 // packages/daemon/src/hook-host.ts
 import { randomBytes } from "crypto";
-import fs13 from "fs";
+import fs14 from "fs";
 import http from "http";
-import path13 from "path";
+import path15 from "path";
 function header(req, name) {
   const value = req.headers[name];
   return Array.isArray(value) ? value[0] : value;
@@ -5322,12 +5706,12 @@ class HookHost {
   askOpenHandler;
   resolveWorkspace;
   local;
-  codexApprovalHoldMs;
-  codexAskSeq = 0;
+  approvalHoldMs;
+  approvalSeq = 0;
   constructor(options) {
     this.endpointFile = options.endpointFile;
-    this.codexApprovalHoldMs = options.codexApprovalHoldMs ?? CODEX_APPROVAL_HOLD_MS;
-    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path13.join(RUNTIME_DIR, "materialised")));
+    this.approvalHoldMs = options.approvalHoldMs ?? APPROVAL_HOLD_MS;
+    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path15.join(RUNTIME_DIR, "materialised")));
   }
   start() {
     const server = http.createServer((req, res) => this.handle(req, res));
@@ -5343,12 +5727,12 @@ class HookHost {
     return promise;
   }
   writeEndpointFile(port) {
-    fs13.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
+    fs14.mkdirSync(path15.dirname(this.endpointFile), { recursive: true });
     const tmp = `${this.endpointFile}.tmp`;
-    fs13.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
+    fs14.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
 AXTERM_HOOK_TOKEN=${this.token}
 `);
-    fs13.renameSync(tmp, this.endpointFile);
+    fs14.renameSync(tmp, this.endpointFile);
   }
   registerSession(sessionId, launchToken, onEvent) {
     this.sessions.set(sessionId, { launchToken, onEvent });
@@ -5417,11 +5801,11 @@ AXTERM_HOOK_TOKEN=${this.token}
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf8");
       if (isClaude) {
-        this.handleAgentHook(req, raw, res, mapClaudeHook, "claude");
+        this.handleDecidingAgentHook(req, raw, res, "claude");
         return;
       }
       if (isCodex) {
-        this.handleCodex(req, raw, res);
+        this.handleDecidingAgentHook(req, raw, res, "codex");
         return;
       }
       if (isGemini) {
@@ -5483,7 +5867,7 @@ AXTERM_HOOK_TOKEN=${this.token}
     const events = withConversationId(map(input), { sessionId: named.session_id, subagentId: named.agent_id });
     this.dispatchHookPayloads(auth.session, events, agent);
   }
-  handleCodex(req, raw, res) {
+  handleDecidingAgentHook(req, raw, res, agent) {
     const auth = this.agentHookSession(req);
     if (!auth) {
       res.writeHead(200).end();
@@ -5496,20 +5880,27 @@ AXTERM_HOOK_TOKEN=${this.token}
       res.writeHead(200).end();
       return;
     }
+    const dispatch = () => {
+      const events = withConversationId(mapClaudeHook(input), {
+        sessionId: input.session_id,
+        subagentId: input.agent_id
+      });
+      this.dispatchHookPayloads(auth.session, events, agent);
+    };
     if (input.hook_event_name !== "PermissionRequest") {
       res.writeHead(200).end();
-      this.dispatchHookPayloads(auth.session, mapClaudeHook(input), "codex");
+      dispatch();
       return;
     }
     const question = buildApprovalQuestion(input.tool_name);
-    this.dispatchHookPayloads(auth.session, mapClaudeHook(input), "codex");
-    const askId = `codex-${auth.sessionId}-${this.codexAskSeq++}`;
+    dispatch();
+    const askId = `${agent}-${auth.sessionId}-${this.approvalSeq++}`;
     let fence;
     const settle = (body) => {
       clearTimeout(fence);
       if (res.writableEnded)
         return;
-      const decision = body.status === "answered" ? codexPermissionDecision(question, body.answers, t("codex.approval.denied")) : undefined;
+      const decision = body.status === "answered" ? hookPermissionDecision(question, body.answers, t("agent.approval.denied")) : undefined;
       if (decision === undefined) {
         res.writeHead(200).end();
         return;
@@ -5530,7 +5921,7 @@ AXTERM_HOOK_TOKEN=${this.token}
         return;
       this.pendingAsks.delete(askId);
       settle({ status: "cancelled" });
-    }, this.codexApprovalHoldMs);
+    }, this.approvalHoldMs);
     fence.unref?.();
   }
   agentHookSession(req) {
@@ -5634,8 +6025,112 @@ var init_hook_host = __esm(() => {
   MAX_BODY_BYTES = 256 * 1024;
 });
 
+// packages/daemon/src/process-guards.ts
+class RejectionLogLimiter {
+  detailLimit;
+  windowMs;
+  windowStartedAt;
+  details = 0;
+  noticeEmitted = false;
+  constructor(detailLimit = DEFAULT_REJECTION_DETAILS, windowMs = DEFAULT_REJECTION_WINDOW_MS) {
+    this.detailLimit = detailLimit;
+    this.windowMs = windowMs;
+    if (!Number.isInteger(detailLimit) || detailLimit < 1)
+      throw new RangeError("detailLimit must be a positive integer");
+    if (!Number.isFinite(windowMs) || windowMs <= 0)
+      throw new RangeError("windowMs must be positive");
+  }
+  decide(now) {
+    if (this.windowStartedAt === undefined || now - this.windowStartedAt >= this.windowMs || now < this.windowStartedAt) {
+      this.windowStartedAt = now;
+      this.details = 0;
+      this.noticeEmitted = false;
+    }
+    if (this.details < this.detailLimit) {
+      this.details++;
+      return "detail";
+    }
+    if (!this.noticeEmitted) {
+      this.noticeEmitted = true;
+      return "notice";
+    }
+    return "drop";
+  }
+}
+function thrownText(reason) {
+  let text;
+  if (reason instanceof Error) {
+    text = reason.stack ?? reason.message;
+  } else if (typeof reason === "string") {
+    text = reason;
+  } else {
+    try {
+      text = JSON.stringify(reason) ?? String(reason);
+    } catch {
+      text = String(reason);
+    }
+  }
+  if (text.length <= MAX_BREADCRUMB_CHARS)
+    return text;
+  return `${text.slice(0, MAX_BREADCRUMB_CHARS)}\u2026 [truncated]`;
+}
+
+class ProcessCrashGuards {
+  options;
+  limiter;
+  now;
+  fatal = false;
+  uninstallCurrent;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.limiter = new RejectionLogLimiter(options.rejectionDetailsPerWindow, options.rejectionWindowMs);
+  }
+  install(events) {
+    if (this.uninstallCurrent !== undefined)
+      throw new Error("process crash guards are already installed");
+    const uncaught = (reason) => this.fatalExit("uncaughtException", reason);
+    const rejected = (reason) => this.unhandledRejection(reason);
+    events.on("uncaughtException", uncaught);
+    events.on("unhandledRejection", rejected);
+    let installed = true;
+    const uninstall = () => {
+      if (!installed)
+        return;
+      installed = false;
+      events.off("uncaughtException", uncaught);
+      events.off("unhandledRejection", rejected);
+      if (this.uninstallCurrent === uninstall)
+        this.uninstallCurrent = undefined;
+    };
+    this.uninstallCurrent = uninstall;
+    return uninstall;
+  }
+  startupFailed(reason) {
+    this.fatalExit("startupFailure", reason);
+  }
+  unhandledRejection(reason) {
+    if (this.fatal)
+      return;
+    const decision = this.limiter.decide(this.now());
+    if (decision === "detail") {
+      this.options.log(`unhandledRejection: ${thrownText(reason)}`);
+    } else if (decision === "notice") {
+      this.options.log("unhandledRejection: suppressing further unhandled rejections in this rate-limit window");
+    }
+  }
+  fatalExit(origin, reason) {
+    if (this.fatal)
+      return;
+    this.fatal = true;
+    this.options.log(`${origin}: ${thrownText(reason)}`);
+    this.options.exit(1);
+  }
+}
+var DEFAULT_REJECTION_DETAILS = 20, DEFAULT_REJECTION_WINDOW_MS = 60000, MAX_BREADCRUMB_CHARS = 16384;
+
 // packages/daemon/src/rpc-server.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import net2 from "net";
 function writeFrame(socket, frame) {
   if (!socket.destroyed)
@@ -5873,7 +6368,7 @@ function startRpcServer(options) {
   });
   if (process.platform !== "win32") {
     try {
-      fs14.unlinkSync(pipePath);
+      fs15.unlinkSync(pipePath);
     } catch {}
   }
   server.listen(pipePath, () => {
@@ -5888,21 +6383,21 @@ var init_rpc_server = __esm(() => {
 });
 
 // packages/daemon/src/codex-home.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path16 from "path";
 function codexTrustKeyPath(home) {
   const resolved = (() => {
     try {
-      return fs15.realpathSync.native(home);
+      return fs16.realpathSync.native(home);
     } catch {
-      return path14.resolve(home);
+      return path16.resolve(home);
     }
   })();
-  return path14.join(resolved, "hooks.json");
+  return path16.join(resolved, "hooks.json");
 }
 function referenceCredential(source, target, ops) {
-  const symlink = ops?.symlink ?? ((s, t2) => fs15.symlinkSync(s, t2, "file"));
-  const link = ops?.link ?? fs15.linkSync;
+  const symlink = ops?.symlink ?? ((s, t2) => fs16.symlinkSync(s, t2, "file"));
+  const link = ops?.link ?? fs16.linkSync;
   try {
     symlink(source, target);
     return "symlink";
@@ -5911,8 +6406,8 @@ function referenceCredential(source, target, ops) {
       link(source, target);
       return "hardlink";
     } catch {
-      fs15.copyFileSync(source, target);
-      fs15.chmodSync(target, 384);
+      fs16.copyFileSync(source, target);
+      fs16.chmodSync(target, 384);
       return "copy";
     }
   }
@@ -5999,8 +6494,8 @@ function slugifyBranch(branch) {
 var MAX_SLUG_LENGTH = 60;
 
 // packages/daemon/src/git.ts
-import fs16 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path17 from "path";
 async function git(ws, cwd, args) {
   const run = await ws.exec(["git", ...args], cwd);
   return {
@@ -6017,15 +6512,15 @@ async function gitOrThrow(ws, cwd, args) {
   return result.stdout;
 }
 function canonicalPath(target) {
-  let resolved = path15.resolve(target);
+  let resolved = path17.resolve(target);
   try {
-    resolved = fs16.realpathSync.native(resolved);
+    resolved = fs17.realpathSync.native(resolved);
   } catch {}
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 async function resolveRepoRoot(ws, cwd) {
   const result = await git(ws, cwd, ["rev-parse", "--show-toplevel"]);
-  return result.ok ? path15.resolve(result.stdout) : undefined;
+  return result.ok ? path17.resolve(result.stdout) : undefined;
 }
 async function currentBranch(ws, cwd) {
   const result = await git(ws, cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -6034,8 +6529,8 @@ async function currentBranch(ws, cwd) {
 async function listWorktrees(ws, repoRoot) {
   return parseWorktreeList(await gitOrThrow(ws, repoRoot, ["worktree", "list", "--porcelain"]));
 }
-function worktreePathFor(repoRoot, branch, root = path15.join(STATE_DIR, "worktrees")) {
-  return path15.join(root, slugifyBranch(path15.basename(repoRoot)), slugifyBranch(branch));
+function worktreePathFor(repoRoot, branch, root = path17.join(STATE_DIR, "worktrees")) {
+  return path17.join(root, slugifyBranch(path17.basename(repoRoot)), slugifyBranch(branch));
 }
 async function createWorktree(ws, options) {
   const { repoRoot, branch, base } = options;
@@ -6043,7 +6538,7 @@ async function createWorktree(ws, options) {
   const existing = (await listWorktrees(ws, repoRoot)).find((w) => canonicalPath(w.path) === canonicalPath(target));
   if (existing)
     return { path: target, branch, createdBranch: false };
-  fs16.mkdirSync(path15.dirname(target), { recursive: true });
+  fs17.mkdirSync(path17.dirname(target), { recursive: true });
   const exists = (await git(ws, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).ok;
   const args = exists ? ["worktree", "add", target, branch] : ["worktree", "add", "-b", branch, target, ...base !== undefined ? [base] : []];
   await gitOrThrow(ws, repoRoot, args);
@@ -6104,7 +6599,7 @@ async function diffStat(ws, worktreePath, base) {
   const untracked = await untrackedFiles(ws, worktreePath);
   let newLines = 0;
   for (const file of untracked)
-    newLines += await countLines(ws, path15.join(worktreePath, file));
+    newLines += await countLines(ws, path17.join(worktreePath, file));
   return {
     filesChanged: a.filesChanged + b.filesChanged + untracked.length,
     insertions: a.insertions + b.insertions + newLines,
@@ -6127,21 +6622,84 @@ async function changedFiles(ws, worktreePath, base, limit = 20) {
     names.add(file);
   return [...names].slice(0, limit);
 }
-var UNTRACKED_LINE_SCAN_LIMIT;
+async function diffPatch(ws, worktreePath, base, maxChars = 64 * 1024) {
+  const parts = [];
+  let size = 0;
+  const push = (text) => {
+    if (size >= maxChars)
+      return false;
+    const room = maxChars - size;
+    const piece = text.length > room ? text.slice(0, room) : text;
+    parts.push(piece);
+    size += piece.length;
+    return piece.length === text.length;
+  };
+  for (const args of [
+    ["diff", `${base}...HEAD`, "--", "."],
+    ["diff", "HEAD"]
+  ]) {
+    const out = await git(ws, worktreePath, args);
+    if (out.ok && out.stdout.trim().length > 0 && !push(`${out.stdout.replace(/\s+$/, "")}
+`)) {
+      return parts.join("");
+    }
+  }
+  for (const file of await untrackedFiles(ws, worktreePath)) {
+    if (size >= maxChars)
+      break;
+    let text;
+    try {
+      const stat = await ws.stat(path17.join(worktreePath, file));
+      if (stat?.kind !== "file" || stat.size > UNTRACKED_LINE_SCAN_LIMIT)
+        continue;
+      text = new TextDecoder().decode(await ws.read(path17.join(worktreePath, file)));
+    } catch {
+      continue;
+    }
+    if (text.slice(0, 8000).includes("\x00")) {
+      if (!push(`diff --git a/${file} b/${file}
+Binary files /dev/null and b/${file} differ
+`))
+        break;
+      continue;
+    }
+    const lines = text.split(`
+`);
+    if (lines.at(-1) === "")
+      lines.pop();
+    const shown = lines.slice(0, UNTRACKED_PATCH_LINES);
+    const body = shown.map((line) => `+${line}`).join(`
+`);
+    const elided = lines.length > shown.length ? `
++\u2026 ${lines.length - shown.length} more lines
+` : `
+`;
+    const header2 = `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1,${lines.length} @@
+`;
+    if (!push(`${header2}${body}${elided}`))
+      break;
+  }
+  return parts.join("");
+}
+var UNTRACKED_LINE_SCAN_LIMIT, UNTRACKED_PATCH_LINES = 40;
 var init_git = __esm(() => {
   init_paths();
   UNTRACKED_LINE_SCAN_LIMIT = 1024 * 1024;
 });
 
 // packages/daemon/src/claude-store.ts
-import fs17 from "fs";
-import os4 from "os";
-import path16 from "path";
+import fs18 from "fs";
+import os5 from "os";
+import path18 from "path";
 function claudeConfigDir(env = process.env) {
   const override = env["CLAUDE_CONFIG_DIR"];
   if (override !== undefined && override.length > 0)
     return override;
-  return path16.join(os4.homedir(), ".claude");
+  return path18.join(os5.homedir(), ".claude");
 }
 function resumedConversationId(argv) {
   for (let i = 0;i < argv.length; i++) {
@@ -6157,41 +6715,41 @@ function resumedConversationId(argv) {
   return;
 }
 function claudeConversationExists(configDir, conversationId) {
-  const projects = path16.join(configDir, "projects");
+  const projects = path18.join(configDir, "projects");
   let entries;
   try {
-    entries = fs17.readdirSync(projects);
+    entries = fs18.readdirSync(projects);
   } catch {
     return;
   }
   const file = `${conversationId}.jsonl`;
   for (const entry of entries) {
     try {
-      if (fs17.existsSync(path16.join(projects, entry, file)))
+      if (fs18.existsSync(path18.join(projects, entry, file)))
         return true;
     } catch {}
   }
   return false;
 }
 function claudeConversationCwd(configDir, conversationId) {
-  const projects = path16.join(configDir, "projects");
+  const projects = path18.join(configDir, "projects");
   let entries;
   try {
-    entries = fs17.readdirSync(projects);
+    entries = fs18.readdirSync(projects);
   } catch {
     return;
   }
   for (const entry of entries) {
-    const file = path16.join(projects, entry, `${conversationId}.jsonl`);
+    const file = path18.join(projects, entry, `${conversationId}.jsonl`);
     let head;
     try {
-      const handle = fs17.openSync(file, "r");
+      const handle = fs18.openSync(file, "r");
       try {
         const buffer = Buffer.alloc(64 * 1024);
-        const read = fs17.readSync(handle, buffer, 0, buffer.byteLength, 0);
+        const read = fs18.readSync(handle, buffer, 0, buffer.byteLength, 0);
         head = buffer.subarray(0, read).toString("utf8");
       } finally {
-        fs17.closeSync(handle);
+        fs18.closeSync(handle);
       }
     } catch {
       continue;
@@ -6215,7 +6773,7 @@ var init_claude_store = __esm(() => {
 });
 
 // packages/daemon/src/injector.ts
-import { setTimeout as delay2 } from "timers/promises";
+import { setTimeout as delay3 } from "timers/promises";
 
 class Injector {
   queues = new Map;
@@ -6230,14 +6788,14 @@ class Injector {
       try {
         const deadline = Date.now() + 5000;
         while (!session.pasteReady && !session.isExited && Date.now() < deadline) {
-          await delay2(100);
+          await delay3(100);
         }
         session.write(CTRL_U);
-        await delay2(CLEAR_SETTLE_MS);
+        await delay3(CLEAR_SETTLE_MS);
         for (const chunk of iteratePasteChunks(text)) {
           session.write(chunk);
         }
-        await delay2(SUBMIT_DELAY_MS);
+        await delay3(SUBMIT_DELAY_MS);
         session.write(SUBMIT);
       } catch (err) {
         session.write(BRACKETED_PASTE_END);
@@ -6249,7 +6807,7 @@ class Injector {
   interrupt(session) {
     return this.enqueue(session.info.id, async () => {
       session.write(ESC);
-      await delay2(500);
+      await delay3(500);
     });
   }
 }
@@ -6459,18 +7017,18 @@ var init_pty_host_client = __esm(() => {
 
 // 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";
+import fs19 from "fs";
+import os6 from "os";
+import path19 from "path";
 function hostFile(runtimeDir) {
-  return path17.join(runtimeDir, "pty-host.json");
+  return path19.join(runtimeDir, "pty-host.json");
 }
 function readPtyHostIn(runtimeDir) {
   return readPtyHostFile(hostFile(runtimeDir));
 }
 function readPtyHostFile(file) {
   try {
-    const parsed = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs19.readFileSync(file, "utf8"));
     if (typeof parsed !== "object" || parsed === null)
       return;
     const { pid, endpoint, token, version: version2 } = parsed;
@@ -6490,8 +7048,8 @@ function isRunning(pid) {
   }
 }
 function hostEndpoint(runtimeDir) {
-  const base = ipcEndpoint(process.platform, os5.userInfo().username, { runtimeDir });
-  return process.platform === "win32" ? `${base}-pty` : path17.join(runtimeDir, "axterm-pty.sock");
+  const base = ipcEndpoint(process.platform, os6.userInfo().username, { runtimeDir });
+  return process.platform === "win32" ? `${base}-pty` : path19.join(runtimeDir, "axterm-pty.sock");
 }
 async function ensurePtyHost(location) {
   const file = hostFile(location.runtimeDir);
@@ -6502,7 +7060,7 @@ async function ensurePtyHost(location) {
     log(`pty host: handoff file names a dead pid ${existing.pid}, starting a new host`);
   const endpoint = hostEndpoint(location.runtimeDir);
   if (process.platform !== "win32")
-    fs18.rmSync(endpoint, { force: true });
+    fs19.rmSync(endpoint, { force: true });
   const token = shortHash(`${location.runtimeDir}:${Date.now()}:${Math.random()}`) + shortHash(String(process.pid));
   const launch = ptyHostLaunch({ execPath: process.execPath, mainScript: location.mainScript ?? Bun.main });
   const child = spawn3(launch.command, launch.args, {
@@ -6531,10 +7089,41 @@ async function ensurePtyHost(location) {
   }
 }
 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);
+  const dir = path19.dirname(file);
+  const tmp = `${file}.tmp`;
+  fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+  let handle;
+  try {
+    handle = fs19.openSync(tmp, "w", 384);
+    fs19.writeFileSync(handle, `${JSON.stringify(info, null, 2)}
+`, "utf8");
+    fs19.fsyncSync(handle);
+    fs19.closeSync(handle);
+    handle = undefined;
+    restrictFile(tmp);
+    fs19.renameSync(tmp, file);
+    restrictFile(file);
+    if (process.platform !== "win32") {
+      try {
+        const directory = fs19.openSync(dir, "r");
+        try {
+          fs19.fsyncSync(directory);
+        } finally {
+          fs19.closeSync(directory);
+        }
+      } catch {}
+    }
+  } catch (err) {
+    if (handle !== undefined) {
+      try {
+        fs19.closeSync(handle);
+      } catch {}
+    }
+    try {
+      fs19.rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
 }
 var init_pty_host_launch = __esm(() => {
   init_src();
@@ -6543,8 +7132,8 @@ var init_pty_host_launch = __esm(() => {
 });
 
 // packages/daemon/src/pty.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import path18 from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import path20 from "path";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 
 class Fanout {
@@ -6565,13 +7154,13 @@ class Fanout {
 }
 function killTree(pid, exeName) {
   if (process.platform === "win32") {
-    const check = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
+    const check = spawnSync3("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
       encoding: "utf8",
       windowsHide: true
     });
     const image = check.stdout?.split(",")[0]?.replace(/"/g, "").toLowerCase() ?? "";
     if (image === exeName) {
-      spawnSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
+      spawnSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
     }
     return;
   }
@@ -6644,7 +7233,7 @@ function spawnPty(options) {
       }
     }
   });
-  handle = new BunPtyHandle(proc, path18.basename(options.exe).toLowerCase());
+  handle = new BunPtyHandle(proc, path20.basename(options.exe).toLowerCase());
   proc.exited.then((code) => handle?.finish(code ?? null));
   return handle;
 }
@@ -6652,7 +7241,7 @@ var init_pty = () => {};
 
 // packages/daemon/src/occupancy.ts
 import { spawn as spawn4 } from "child_process";
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 function shellOccupied(shellPid) {
   return process.platform === "win32" ? occupiedFromSnapshot(shellPid) : occupiedFromPidProbe(shellPid);
 }
@@ -6697,11 +7286,11 @@ async function occupiedFromSnapshot(shellPid) {
 }
 async function childrenViaProc(pid) {
   try {
-    const children = await fs19.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    const children = await fs20.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
     return children.trim().length > 0;
   } catch {
     try {
-      await fs19.access(`/proc/${pid}`);
+      await fs20.access(`/proc/${pid}`);
       return;
     } catch {
       return false;
@@ -6765,20 +7354,20 @@ var init_occupancy = __esm(() => {
 });
 
 // packages/daemon/src/agent-store.ts
-import fs20 from "fs";
-import os6 from "os";
-import path19 from "path";
+import fs21 from "fs";
+import os7 from "os";
+import path21 from "path";
 import { Database as Database3 } from "bun:sqlite";
 function readTailLines(file, maxBytes) {
   let fd;
   try {
-    fd = fs20.openSync(file, "r");
-    const size = fs20.fstatSync(fd).size;
+    fd = fs21.openSync(file, "r");
+    const size = fs21.fstatSync(fd).size;
     if (size === 0)
       return [];
     const length = Math.min(size, maxBytes);
     const buffer = Buffer.allocUnsafe(length);
-    fs20.readSync(fd, buffer, 0, length, size - length);
+    fs21.readSync(fd, buffer, 0, length, size - length);
     const text = buffer.toString("utf8");
     const lines = text.split(`
 `);
@@ -6791,46 +7380,46 @@ function readTailLines(file, maxBytes) {
     return [];
   } finally {
     if (fd !== undefined)
-      fs20.closeSync(fd);
+      fs21.closeSync(fd);
   }
 }
 function claudeConfigDir2() {
-  return process.env["CLAUDE_CONFIG_DIR"] ?? path19.join(os6.homedir(), ".claude");
+  return process.env["CLAUDE_CONFIG_DIR"] ?? path21.join(os7.homedir(), ".claude");
 }
 function codexHome() {
-  return path19.join(STATE_DIR, "codex-home");
+  return path21.join(STATE_DIR, "codex-home");
 }
 function ompAgentDb() {
-  return path19.join(os6.homedir(), ".omp", "agent", "agent.db");
+  return path21.join(os7.homedir(), ".omp", "agent", "agent.db");
 }
 function findCodexRollout(sessionId) {
-  const root = path19.join(codexHome(), "sessions");
+  const root = path21.join(codexHome(), "sessions");
   for (const shard2 of codexRolloutShards(sessionId)) {
-    const dir = path19.join(root, ...shard2.split("/"));
+    const dir = path21.join(root, ...shard2.split("/"));
     let entries;
     try {
-      entries = fs20.readdirSync(dir);
+      entries = fs21.readdirSync(dir);
     } catch {
       continue;
     }
     const match2 = entries.find((name) => name.endsWith(`-${sessionId}.jsonl`));
     if (match2 !== undefined)
-      return path19.join(dir, match2);
+      return path21.join(dir, match2);
   }
   return;
 }
 function newestCodexRollout() {
-  const root = path19.join(codexHome(), "sessions");
+  const root = path21.join(codexHome(), "sessions");
   let best;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs20.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path19.join(dir, entry.name);
+      const full = path21.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (depth < 3)
           walk(full, depth + 1);
@@ -6839,7 +7428,7 @@ function newestCodexRollout() {
       if (!entry.name.endsWith(".jsonl"))
         continue;
       try {
-        const { mtimeMs } = fs20.statSync(full);
+        const { mtimeMs } = fs21.statSync(full);
         if (!best || mtimeMs > best.mtimeMs)
           best = { file: full, mtimeMs };
       } catch {}
@@ -6850,7 +7439,7 @@ function newestCodexRollout() {
 }
 function ompQuotaFacts() {
   const file = ompAgentDb();
-  if (!fs20.existsSync(file))
+  if (!fs21.existsSync(file))
     return { agent: "omp", kind: "gauge" };
   let db;
   try {
@@ -6882,7 +7471,7 @@ function claudeQuotaFacts(sessions) {
   for (const session of sessions) {
     if (session.agentSessionId === undefined)
       continue;
-    const file = path19.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
+    const file = path21.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
     const event = parseClaudeLimitEvent(readTailLines(file, QUOTA_TAIL_BYTES));
     if (event && (!newest || event.at > newest.at))
       newest = event;
@@ -6914,11 +7503,11 @@ function collectQuotaFacts(agents, sessions, onPath) {
 function storeQuietForMs(agent, cwd, agentSessionId, nowMs) {
   if (agentSessionId === undefined)
     return;
-  const file = agent === "claude" ? path19.join(claudeConfigDir2(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
+  const file = agent === "claude" ? path21.join(claudeConfigDir2(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
   if (file === undefined)
     return;
   try {
-    return Math.max(0, nowMs - fs20.statSync(file).mtimeMs);
+    return Math.max(0, nowMs - fs21.statSync(file).mtimeMs);
   } catch {
     return;
   }
@@ -6928,15 +7517,15 @@ function readFileRange(file, from, to) {
     return "";
   let fd;
   try {
-    fd = fs20.openSync(file, "r");
+    fd = fs21.openSync(file, "r");
     const buffer = Buffer.allocUnsafe(to - from);
-    const read = fs20.readSync(fd, buffer, 0, to - from, from);
+    const read = fs21.readSync(fd, buffer, 0, to - from, from);
     return buffer.subarray(0, read).toString("utf8");
   } catch {
     return "";
   } finally {
     if (fd !== undefined)
-      fs20.closeSync(fd);
+      fs21.closeSync(fd);
   }
 }
 var QUOTA_TAIL_BYTES;
@@ -11429,8 +12018,8 @@ var init_terminal_mirror = __esm(() => {
 });
 
 // packages/daemon/src/pty-session.ts
-import fs21 from "fs";
-import path20 from "path";
+import fs22 from "fs";
+import path22 from "path";
 
 class PtySession {
   info;
@@ -11535,10 +12124,10 @@ class PtySession {
   }
   saveScrollback() {
     try {
-      const file = path20.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
+      const file = path22.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
       const tmp = `${file}.tmp`;
-      fs21.writeFileSync(tmp, this.serializeBuffer(), "utf8");
-      fs21.renameSync(tmp, file);
+      fs22.writeFileSync(tmp, this.serializeBuffer(), "utf8");
+      fs22.renameSync(tmp, file);
     } catch (err) {
       log(`scrollback save failed for ${this.info.shortId}: ${String(err)}`);
     }
@@ -11560,9 +12149,9 @@ var init_pty_session = __esm(() => {
 // packages/daemon/src/session-manager.ts
 import { randomBytes as randomBytes2, randomUUID } from "crypto";
 import { spawn as spawn5 } from "child_process";
-import fs22 from "fs";
-import os7 from "os";
-import path21 from "path";
+import fs23 from "fs";
+import os8 from "os";
+import path23 from "path";
 function sessionScratchRoot(info) {
   return info.worktreePath ?? info.cwd;
 }
@@ -11612,11 +12201,15 @@ function pidIsRunning(pid) {
     return err.code === "EPERM";
   }
 }
+function ptyHostEnabled(env) {
+  return env["AXTERM_PTY_HOST"] !== "0";
+}
 
 class SessionManager {
   store;
   hooks;
   configuredDefaults;
+  ptyHostPolicy;
   live = new Map;
   agentRuntime = new Map;
   injector = new Injector;
@@ -11624,10 +12217,14 @@ class SessionManager {
   eventListeners = new Set;
   rawHookListeners = new Set;
   workspace = new LocalWorkspace(MATERIALISED_DIR);
-  constructor(store, hooks, configuredDefaults = () => ({})) {
+  constructor(store, hooks, configuredDefaults = () => ({}), ptyHostPolicy = {
+    enabled: ptyHostEnabled(process.env),
+    ...process.env["AXTERM_PTY_HOST_MAIN"] ? { mainScript: process.env["AXTERM_PTY_HOST_MAIN"] } : {}
+  }) {
     this.store = store;
     this.hooks = hooks;
     this.configuredDefaults = configuredDefaults;
+    this.ptyHostPolicy = ptyHostPolicy;
     this.sessionWatch = setInterval(() => this.tickSessions(), SESSION_TICK_MS);
     this.sessionWatch.unref();
   }
@@ -11664,7 +12261,7 @@ class SessionManager {
     return { adopted: adoptedIds.length, sweptExited };
   }
   async hostSessions() {
-    if (process.env["AXTERM_PTY_HOST"] !== "1")
+    if (!this.ptyHostPolicy.enabled)
       return new Map;
     const existing = readPtyHostIn(RUNTIME_DIR);
     if (existing === undefined)
@@ -11753,13 +12350,14 @@ class SessionManager {
     return {
       stat: await diffStat(ws, target, compare),
       files: await changedFiles(ws, target, compare),
+      patch: await diffPatch(ws, target, compare),
       base: compare,
       ...info.branch !== undefined ? { branch: info.branch } : {}
     };
   }
   async create(params) {
-    const requestedCwd = params.cwd ? path21.resolve(params.cwd) : os7.homedir();
-    if (!fs22.existsSync(requestedCwd)) {
+    const requestedCwd = params.cwd ? path23.resolve(params.cwd) : os8.homedir();
+    if (!fs23.existsSync(requestedCwd)) {
       throw new AxtermError("err.cwd.missing", { cwd: requestedCwd });
     }
     let worktree;
@@ -11815,14 +12413,14 @@ class SessionManager {
         sessionCwd = resolveSessionCwd({
           requested: cwd,
           preferConversation: params.preferConversationCwd === true,
-          ...recorded !== undefined && fs22.existsSync(recorded) ? { conversationCwd: recorded } : {}
+          ...recorded !== undefined && fs23.existsSync(recorded) ? { conversationCwd: recorded } : {}
         });
       }
     }
     const info = {
       id,
       shortId: id.slice(0, 6),
-      name: params.name ?? worktree?.branch ?? path21.basename(sessionCwd),
+      name: params.name ?? worktree?.branch ?? path23.basename(sessionCwd),
       cwd: sessionCwd,
       shell: shell.kind,
       agentCommand,
@@ -11846,7 +12444,7 @@ class SessionManager {
       launchToken
     });
     const file = this.claudeSettingsPath(id);
-    fs22.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
+    fs23.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
   }
   writeGeminiSettings(sessionId) {
     try {
@@ -11859,8 +12457,8 @@ class SessionManager {
       });
       const file = this.geminiSettingsPath();
       const tmp = `${file}.tmp`;
-      fs22.writeFileSync(tmp, JSON.stringify(settings, null, 2));
-      fs22.renameSync(tmp, file);
+      fs23.writeFileSync(tmp, JSON.stringify(settings, null, 2));
+      fs23.renameSync(tmp, file);
     } catch (err) {
       log(`gemini settings write failed; session starts without hooks: ${String(err)}`);
     }
@@ -11889,7 +12487,7 @@ class SessionManager {
         return;
       }
       this.watchCodexAppServer(id, url, pid);
-      fs22.writeFileSync(this.codexAppServerFile(id), JSON.stringify({ pid, url }), { mode: 384 });
+      fs23.writeFileSync(this.codexAppServerFile(id), JSON.stringify({ pid, url }), { mode: 384 });
       log(`codex app-server on ${url} (pid ${pid}) for session ${id.slice(0, 6)} in ${cwd}`);
       return url;
     } catch (err) {
@@ -11898,13 +12496,13 @@ class SessionManager {
     }
   }
   codexAppServerFile(id) {
-    return path21.join(RUNTIME_DIR, `codex-app-${id}.json`);
+    return path23.join(RUNTIME_DIR, `codex-app-${id}.json`);
   }
   adoptCodexAppServer(id) {
     const file = this.codexAppServerFile(id);
     let record;
     try {
-      record = JSON.parse(fs22.readFileSync(file, "utf8"));
+      record = JSON.parse(fs23.readFileSync(file, "utf8"));
     } catch {
       return;
     }
@@ -11913,7 +12511,7 @@ class SessionManager {
     if (typeof pid !== "number" || typeof url !== "string")
       return;
     if (!pidIsRunning(pid)) {
-      fs22.rmSync(file, { force: true });
+      fs23.rmSync(file, { force: true });
       return;
     }
     this.watchCodexAppServer(id, url, pid);
@@ -11927,7 +12525,7 @@ class SessionManager {
       stop: () => {
         client.close();
         this.killCodexAppServer(pid);
-        fs22.rmSync(this.codexAppServerFile(id), { force: true });
+        fs23.rmSync(this.codexAppServerFile(id), { force: true });
       }
     });
   }
@@ -11941,22 +12539,22 @@ class SessionManager {
     this.codexServers.delete(id);
   }
   ensureCodexHome() {
-    const home = path21.join(STATE_DIR, "codex-home");
-    fs22.mkdirSync(home, { recursive: true, mode: 448 });
+    const home = path23.join(STATE_DIR, "codex-home");
+    fs23.mkdirSync(home, { recursive: true, mode: 448 });
     this.linkCodexAuth(home);
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
     const hooksFile = buildCodexHooks({ command: bridge.command, args: bridge.args });
     const hooksPath = codexTrustKeyPath(home);
     const tmp = `${hooksPath}.tmp`;
-    fs22.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
-    fs22.renameSync(tmp, hooksPath);
+    fs23.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
+    fs23.renameSync(tmp, hooksPath);
     const entries = codexHookTrust(hooksPath, hooksFile);
-    const configPath = path21.join(home, "config.toml");
-    const existing = fs22.existsSync(configPath) ? fs22.readFileSync(configPath, "utf8") : "";
+    const configPath = path23.join(home, "config.toml");
+    const existing = fs23.existsSync(configPath) ? fs23.readFileSync(configPath, "utf8") : "";
     const missing = entries.filter((e) => !existing.includes(`"${e.key.replaceAll("\\", "\\\\")}"`));
     if (missing.length > 0) {
       const block = codexTrustStateToml(missing);
-      fs22.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
+      fs23.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
 `) ? `
 ${block}` : block);
     }
@@ -11969,12 +12567,12 @@ ${block}` : block);
     return home;
   }
   linkCodexAuth(home) {
-    const target = path21.join(home, "auth.json");
-    if (fs22.existsSync(target))
+    const target = path23.join(home, "auth.json");
+    if (fs23.existsSync(target))
       return;
-    const operatorHome = process.env["CODEX_HOME"] ?? path21.join(os7.homedir(), ".codex");
-    const source = path21.join(operatorHome, "auth.json");
-    if (!fs22.existsSync(source))
+    const operatorHome = process.env["CODEX_HOME"] ?? path23.join(os8.homedir(), ".codex");
+    const source = path23.join(operatorHome, "auth.json");
+    if (!fs23.existsSync(source))
       throw new AxtermError("err.codex.noAuth", { authFile: source });
     let how;
     try {
@@ -11988,31 +12586,31 @@ ${block}` : block);
   }
   doctorReport() {
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
-    const home = path21.join(STATE_DIR, "codex-home");
-    const operatorHome = process.env["CODEX_HOME"] ?? path21.join(os7.homedir(), ".codex");
-    const authSource = path21.join(operatorHome, "auth.json");
+    const home = path23.join(STATE_DIR, "codex-home");
+    const operatorHome = process.env["CODEX_HOME"] ?? path23.join(os8.homedir(), ".codex");
+    const authSource = path23.join(operatorHome, "auth.json");
     const geminiSettings = this.geminiSettingsPath();
-    const configPath = path21.join(home, "config.toml");
+    const configPath = path23.join(home, "config.toml");
     const read = (file) => {
       try {
-        return fs22.existsSync(file) ? fs22.readFileSync(file, "utf8") : undefined;
+        return fs23.existsSync(file) ? fs23.readFileSync(file, "utf8") : undefined;
       } catch {
         return;
       }
     };
     return [
-      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs22.existsSync(bridge.command) }),
+      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs23.existsSync(bridge.command) }),
       ...evaluateOmpDoctor({
         binary: lookupOnPath("omp"),
         extensionPath: this.hooks.extensionPath,
-        extensionExists: fs22.existsSync(this.hooks.extensionPath)
+        extensionExists: fs23.existsSync(this.hooks.extensionPath)
       }),
       ...evaluateClaudeDoctor({ binary: lookupOnPath("claude") }),
       ...evaluateCodexDoctor({
         binary: lookupOnPath("codex"),
         authSourcePath: authSource,
-        authSourceExists: fs22.existsSync(authSource),
-        homeExists: fs22.existsSync(home),
+        authSourceExists: fs23.existsSync(authSource),
+        homeExists: fs23.existsSync(home),
         expected: codexHookTrust(codexTrustKeyPath(home), buildCodexHooks({ command: bridge.command, args: bridge.args })),
         configToml: read(configPath)
       }),
@@ -12113,10 +12711,14 @@ ${block}` : block);
   }
   answerScreenChoice(idOrPrefix, optionIndex) {
     const session = this.resolveLive(idOrPrefix);
-    const dialog = detectOnboarding(agentIdFromCommand(session.info.agentCommand), session.screenText(30));
+    const agent = agentIdFromCommand(session.info.agentCommand);
+    const dialog = detectOnboarding(agent, session.screenText(30));
     const digit = dialog?.options[optionIndex]?.digit;
     if (digit === undefined) {
-      session.write(buildMenuSelectKeys(optionIndex));
+      const keys2 = menuChoiceKeys(agentProfile(agent), optionIndex);
+      if (keys2 === undefined)
+        throw new AxtermError("err.choose.noSafeKey", { agent, index: optionIndex });
+      session.write(keys2);
       return "menu";
     }
     this.pendingPrompt.delete(session.info.id);
@@ -12149,13 +12751,13 @@ ${block}` : block);
   }
   writeScreenFile(idOrPrefix, lines) {
     const session = this.resolveLive(idOrPrefix);
-    const file = path21.join(path21.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
-    fs22.writeFileSync(file, session.screenText(lines), { mode: 384 });
+    const file = path23.join(path23.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
+    fs23.writeFileSync(file, session.screenText(lines), { mode: 384 });
     return file;
   }
   removeScreenFile(id) {
     try {
-      fs22.rmSync(path21.join(path21.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
+      fs23.rmSync(path23.join(path23.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
     } catch {}
   }
   async stageInboundFile(idOrPrefix, suggestedName, bytes) {
@@ -12164,20 +12766,20 @@ ${block}` : block);
       return this.stageInRuntimeDir(info, suggestedName, bytes);
     const ws = this.workspaceFor(info.id);
     const dir = sessionScratchRoot(info);
-    const file = path21.resolve(planMaterialisedPath(inboundStagingDir(dir), info.id, suggestedName));
+    const file = path23.resolve(planMaterialisedPath(inboundStagingDir(dir), info.id, suggestedName));
     await this.prepareScratchDir(ws, dir, file);
     await ws.write(file, bytes, 384);
-    log(`session ${info.shortId} staged ${path21.basename(file)} (${bytes.byteLength} bytes)`);
+    log(`session ${info.shortId} staged ${path23.basename(file)} (${bytes.byteLength} bytes)`);
     return file;
   }
   stagingMode() {
     return this.configuredDefaults().staging ?? "project";
   }
   async stageInRuntimeDir(info, suggestedName, bytes) {
-    const file = path21.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
-    await 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)`);
+    const file = path23.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
+    await fs23.promises.mkdir(path23.dirname(file), { recursive: true, mode: 448 });
+    await fs23.promises.writeFile(file, bytes, { mode: 384 });
+    log(`session ${info.shortId} staged ${path23.basename(file)} (${bytes.byteLength} bytes, runtime dir)`);
     return file;
   }
   async prepareScratchDir(ws, sessionDir, file) {
@@ -12194,47 +12796,47 @@ ${block}` : block);
       throw new AxtermError("err.staging.notIgnored", { dir: scratch, file: SCRATCH_IGNORE_NAME });
     }
     try {
-      await ws.mkdirp(path21.dirname(file), 448);
+      await ws.mkdirp(path23.dirname(file), 448);
     } catch (err) {
       throw new AxtermError("err.staging.dir", { dir: scratch, error: err instanceof Error ? err.message : String(err) });
     }
   }
   removeStagedFiles(id, info) {
     try {
-      fs22.rmSync(path21.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+      fs23.rmSync(path23.join(MATERIALISED_DIR, id), { recursive: true, force: true });
     } catch {}
     if (info === undefined)
       return;
-    const scratch = path21.resolve(scratchDir(sessionScratchRoot(info)));
+    const scratch = path23.resolve(scratchDir(sessionScratchRoot(info)));
     try {
-      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);
+      fs23.rmSync(path23.resolve(inboundStagingDir(sessionScratchRoot(info)), id), { recursive: true, force: true });
+      fs23.rmdirSync(path23.join(scratch, "inbound"));
+      fs23.rmSync(path23.join(scratch, SCRATCH_IGNORE_NAME), { force: true });
+      fs23.rmdirSync(scratch);
     } catch {}
   }
   removeClaudeSettings(id) {
     try {
-      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 });
+      fs23.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs23.rmSync(this.mcpConfigPath(id), { force: true });
+      fs23.rmSync(this.mcpContextPath(id), { force: true });
+      fs23.rmSync(this.geminiTelemetryPath(id), { force: true });
       this.stopCodexAppServer(id);
     } catch {}
   }
   claudeSettingsPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `claude-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `claude-${id}.json`);
   }
   mcpConfigPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
   }
   mcpContextPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
   }
   writeMcpContext(id, launchToken) {
     const file = this.mcpContextPath(id);
     try {
-      fs22.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
+      fs23.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp context write failed; session starts without axterm's tools: ${String(err)}`);
@@ -12247,7 +12849,7 @@ ${block}` : block);
   writeMcpConfig(id, contextPath) {
     const file = this.mcpConfigPath(id);
     try {
-      fs22.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
+      fs23.writeFileSync(file, claudeMcpConfig(this.mcpServerLaunch(), contextPath), { mode: 384 });
       return file;
     } catch (err) {
       log(`mcp config write failed; session starts without axterm's tools: ${String(err)}`);
@@ -12255,18 +12857,20 @@ ${block}` : block);
     }
   }
   geminiTelemetryPath(id) {
-    return path21.join(path21.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
+    return path23.join(path23.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
   }
   geminiSettingsPath() {
-    return path21.join(path21.dirname(this.hooks.endpointFile), "gemini-defaults.json");
+    return path23.join(path23.dirname(this.hooks.endpointFile), "gemini-defaults.json");
   }
   async ptySpawner() {
-    if (process.env["AXTERM_PTY_HOST"] !== "1" || this.ptyHostUnavailable)
+    if (!this.ptyHostPolicy.enabled || this.ptyHostUnavailable)
       return { spawn: spawnPty, hostOwned: false };
     try {
       if (this.ptyHost === undefined) {
-        const override = process.env["AXTERM_PTY_HOST_MAIN"];
-        const info = await ensurePtyHost({ runtimeDir: RUNTIME_DIR, ...override ? { mainScript: override } : {} });
+        const info = await ensurePtyHost({
+          runtimeDir: RUNTIME_DIR,
+          ...this.ptyHostPolicy.mainScript ? { mainScript: this.ptyHostPolicy.mainScript } : {}
+        });
         this.ptyHost = await connectPtyHost({ endpoint: info.endpoint, token: info.token });
         log(`pty host: connected (pid ${info.pid})`);
       }
@@ -12431,7 +13035,7 @@ ${block}` : block);
       this.store.updateAgentState(id, result.entry.state, "hook", now);
       log(`session ${info.shortId} agent ${runtime.entry?.state ?? "-"} -> ${result.entry.state}`);
       this.emit({ t: "agent.status", sessionId: id, state: result.entry.state, toolName: result.entry.toolName });
-      if (result.entry.state === "blocked" && agentProfile(agentIdFromCommand(info.agentCommand)).structuredApprovals !== true) {
+      if (offersKeystrokeApproval(agentProfile(agentIdFromCommand(info.agentCommand)), result.entry.state)) {
         runtime.choiceSeq += 1;
         this.emit({
           t: "choice.request",
@@ -12556,7 +13160,7 @@ ${block}` : block);
     if (agentCommand === undefined) {
       throw new AxtermError("err.session.noResumeSupport", { agent: profile.displayName });
     }
-    if (!fs22.existsSync(stored.cwd))
+    if (!fs23.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const info = { ...stored, agentCommand, state: "running" };
     delete info.exitCode;
@@ -12630,7 +13234,7 @@ ${block}` : block);
   removeScrollback(id) {
     for (const file of [`${id}.bin`, `${id}.bin.tmp`]) {
       try {
-        fs22.rmSync(path21.join(SCROLLBACK_DIR, file), { force: true });
+        fs23.rmSync(path23.join(SCROLLBACK_DIR, file), { force: true });
       } catch {}
     }
   }
@@ -12643,7 +13247,7 @@ ${block}` : block);
     if (runtime === undefined)
       return;
     try {
-      runtime.telemetryOffset = fs22.statSync(this.geminiTelemetryPath(id)).size;
+      runtime.telemetryOffset = fs23.statSync(this.geminiTelemetryPath(id)).size;
     } catch {}
   }
   drainGeminiTelemetry() {
@@ -12656,7 +13260,7 @@ ${block}` : block);
       const file = this.geminiTelemetryPath(id);
       let size = 0;
       try {
-        size = fs22.statSync(file).size;
+        size = fs23.statSync(file).size;
       } catch {
         continue;
       }
@@ -12752,7 +13356,7 @@ var init_session_manager = __esm(() => {
   init_pty_session();
   init_shell();
   init_workspace_local();
-  MATERIALISED_DIR = path21.join(RUNTIME_DIR, "materialised");
+  MATERIALISED_DIR = path23.join(RUNTIME_DIR, "materialised");
   PROMPT_OPTIONS = {
     hostKey: [{ label: "yes" }, { label: "no" }],
     password: [],
@@ -12904,11 +13508,11 @@ var init_acknowledge = __esm(() => {
 });
 
 // packages/channel-telegram/src/attach.ts
-import fs23 from "fs";
-import path22 from "path";
+import fs24 from "fs";
+import path24 from "path";
 function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELEGRAM_LIMITS) {
-  const name = path22.basename(filePath);
-  const bytes = fs23.statSync(filePath).size;
+  const name = path24.basename(filePath);
+  const bytes = fs24.statSync(filePath).size;
   const plan = planAttachment({ name, bytes }, limits);
   if (plan.kind === "rejected")
     throw new Error(plan.reason);
@@ -12918,7 +13522,7 @@ function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELE
   form.append("message_thread_id", String(topicId));
   if (caption !== undefined && caption.length > 0)
     form.append("caption", caption);
-  form.append(field, new Blob([fs23.readFileSync(filePath)]), name);
+  form.append(field, new Blob([fs24.readFileSync(filePath)]), name);
   return { method: plan.kind === "photo" ? "sendPhoto" : "sendDocument", field, form };
 }
 function isPhotoRejection(error) {
@@ -12926,13 +13530,13 @@ function isPhotoRejection(error) {
   return /IMAGE_PROCESS_FAILED|PHOTO_INVALID_DIMENSIONS|PHOTO_EXT_INVALID|PHOTO_SAVE_FILE_INVALID/i.test(message);
 }
 function asDocumentUpload(filePath, chatId, topicId, caption) {
-  const name = path22.basename(filePath);
+  const name = path24.basename(filePath);
   const form = new FormData;
   form.append("chat_id", String(chatId));
   form.append("message_thread_id", String(topicId));
   if (caption !== undefined && caption.length > 0)
     form.append("caption", caption);
-  form.append("document", new Blob([fs23.readFileSync(filePath)]), name);
+  form.append("document", new Blob([fs24.readFileSync(filePath)]), name);
   return { method: "sendDocument", field: "document", form };
 }
 var TELEGRAM_LIMITS;
@@ -13002,6 +13606,31 @@ function planScreenDelivery(text, maxMessages) {
   const chunks = preChunks(text);
   return chunks.length <= maxMessages ? { kind: "messages", chunks } : { kind: "file", text };
 }
+function diffQuote(summary, limit = TELEGRAM_TEXT_LIMIT, reserved = 0) {
+  const OPEN = "<blockquote expandable><pre>";
+  const CLOSE = "</pre></blockquote>";
+  const budget = limit - reserved - OPEN.length - CLOSE.length;
+  const cut = (total) => escapeHtml(`\u2026 truncated, ${total} characters in the full patch`);
+  const rendered = [];
+  let used = 0;
+  let stopped = false;
+  for (const line of summary.lines) {
+    const marker = line.kind === "add" ? "+" : line.kind === "del" ? "-" : "";
+    const escaped = escapeHtml(`${marker}${line.text}`);
+    if (used + escaped.length + 1 + cut(summary.totalChars).length > budget) {
+      stopped = true;
+      break;
+    }
+    rendered.push(escaped);
+    used += escaped.length + 1;
+  }
+  if (rendered.length === 0)
+    return "";
+  if (stopped || summary.truncated !== undefined)
+    rendered.push(cut(summary.totalChars));
+  return `${OPEN}${rendered.join(`
+`)}${CLOSE}`;
+}
 function parseScreenLines(args) {
   const raw = args[0];
   if (raw === undefined || !/^-?\d+$/.test(raw))
@@ -13476,7 +14105,7 @@ var init_topic_title = __esm(() => {
 });
 
 // packages/channel-telegram/src/adapter.ts
-import { setTimeout as delay3 } from "timers/promises";
+import { setTimeout as delay4 } from "timers/promises";
 function readMedia(msg) {
   const photo = msg.photo?.at(-1);
   if (photo) {
@@ -13512,6 +14141,7 @@ class TelegramChannel {
   titleFlushes = new Map;
   flows = new Map;
   outbound = Promise.resolve();
+  username;
   polling = false;
   stopped = false;
   pollAbort;
@@ -13696,7 +14326,16 @@ class TelegramChannel {
       `${d.stat.filesChanged} files  +${d.stat.insertions}  -${d.stat.deletions}`,
       ...d.files.map((f) => `\u2022 ${f}`)
     ];
-    for (const message of htmlLines(lines)) {
+    const messages = htmlLines(lines);
+    const summary = d.patch === undefined ? undefined : summarizePatch(d.patch);
+    const last = messages.at(-1);
+    if (summary !== undefined && last !== undefined) {
+      const quote = diffQuote(summary, TELEGRAM_TEXT_LIMIT, last.length + 1);
+      if (quote !== "")
+        messages[messages.length - 1] = `${last}
+${quote}`;
+    }
+    for (const message of messages) {
       await this.sendToSession(sessionId, message);
     }
   }
@@ -14119,8 +14758,8 @@ ${code(prompt.line)}`,
         throw new Error("this Telegram client cannot download files");
       const files = [];
       for (const item of batch.items) {
-        const path23 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
-        files.push({ path: path23, kind: item.kind });
+        const path25 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
+        files.push({ path: path25, kind: item.kind });
       }
       await this.control.prompt(batch.sessionId, buildAttachmentPrompt(files, batch.caption));
       this.log(`staged ${files.length} inbound file(s) for ${batch.sessionId}`);
@@ -14135,7 +14774,7 @@ ${code(prompt.line)}`,
   async settleInboundForTest() {
     while (this.albums.size > 0 || this.inboundQueues.size > 0) {
       if (this.albums.size > 0)
-        await delay3(this.albumDebounceMs + 5);
+        await delay4(this.albumDebounceMs + 5);
       await Promise.all([...this.inboundQueues.values()]);
     }
   }
@@ -14144,10 +14783,22 @@ ${code(prompt.line)}`,
       return;
     await this.api.call("setMessageReaction", { chat_id: chatId, message_id: messageId, reaction: reactionPayload(state) }).catch(() => {});
   }
+  async selfUsername() {
+    if (this.username !== undefined)
+      return this.username;
+    try {
+      const me = await this.api.call("getMe");
+      if (typeof me.username === "string" && me.username.length > 0)
+        this.username = me.username;
+    } catch {}
+    return this.username;
+  }
   async handleCommand(text, binding, msg) {
     const [rawCmd = "", ...args] = text.split(/\s+/);
     const rawTail = text.slice(rawCmd.length);
-    const cmd = rawCmd.replace(/@\w+$/, "");
+    const { command: cmd, target } = parseCommandAddress(rawCmd);
+    if (target !== undefined && !commandIsForBot(target, await this.selfUsername()))
+      return;
     if (binding) {
       switch (cmd) {
         case "/esc":
@@ -14303,13 +14954,13 @@ ${code(prompt.line)}`,
         const project = await resolveProject(args[0]);
         if (!project)
           return;
-        const target = args[1];
-        if (target === undefined) {
+        const target2 = args[1];
+        if (target2 === undefined) {
           await reply(t("tg.usage.rm"));
           return;
         }
-        const result = await this.control.removeWorktree(project.alias, target, args[2] === "force");
-        await reply(result.removed ? t("tg.worktree.removed", { target }) : t("tg.worktree.refused", { reason: String(result.reason) }));
+        const result = await this.control.removeWorktree(project.alias, target2, args[2] === "force");
+        await reply(result.removed ? t("tg.worktree.removed", { target: target2 }) : t("tg.worktree.refused", { reason: String(result.reason) }));
         return;
       }
       case "/sessions": {
@@ -14407,8 +15058,12 @@ ${code(prompt.line)}`,
       return;
     }
     if (flow.askId === undefined) {
-      const keys2 = agentProfile(agentIdFromCommand(session.agentCommand)).approvalKeys;
-      this.control.write(session.id, keys2 !== undefined && decoded.optionIndex <= 1 ? decoded.optionIndex === 0 ? keys2.allow : keys2.deny : buildMenuSelectKeys(decoded.optionIndex));
+      const keys2 = menuChoiceKeys(agentProfile(agentIdFromCommand(session.agentCommand)), decoded.optionIndex);
+      if (keys2 === undefined) {
+        await answer(t("tg.answer.noSafeKey"));
+        return;
+      }
+      this.control.write(session.id, keys2);
     }
     flow.answers.push({ questionIndex: flow.cursor, selected: [label] });
     flow.cursor += 1;
@@ -14461,6 +15116,11 @@ ${code(prompt.line)}`,
       clearTimeout(album.timer);
     this.albums.clear();
   }
+  pollHealth() {
+    return this.pollError;
+  }
+  pollError;
+  pollWarned = false;
   async pollLoop() {
     while (this.polling) {
       try {
@@ -14471,6 +15131,10 @@ ${code(prompt.line)}`,
         });
         if (this.stopped)
           return;
+        if (this.pollError !== undefined)
+          this.log("polling recovered");
+        this.pollError = undefined;
+        this.pollWarned = false;
         for (const update2 of updates) {
           this.updateOffset = Math.max(this.updateOffset, update2.update_id + 1);
           await this.handleUpdate(update2);
@@ -14480,11 +15144,29 @@ ${code(prompt.line)}`,
       } catch (err) {
         if (!this.polling)
           return;
-        this.log(`poll failed: ${String(err)}`);
-        await delay3(3000);
+        const reason = String(err);
+        this.pollError = reason;
+        this.log(`poll failed: ${reason}`);
+        if (!this.pollWarned) {
+          this.pollWarned = true;
+          this.warnPollFailure(reason);
+        }
+        await delay4(3000);
       }
     }
   }
+  async warnPollFailure(reason) {
+    const conflict = /\b409\b|terminated by other getUpdates/i.test(reason);
+    const text = conflict ? tHtml("tg.poll.conflict", { machine: this.config.machine.name }) : tHtml("tg.poll.failed", { machine: this.config.machine.name, reason: oneLineReason(reason) });
+    try {
+      await this.api.call("sendMessage", { chat_id: this.config.groupId, text, parse_mode: "HTML" });
+    } catch (err) {
+      this.log(`could not report the poll failure: ${String(err)}`);
+    }
+  }
+}
+function oneLineReason(reason) {
+  return reason.replace(/\s+/g, " ").trim().slice(0, 200);
 }
 var SCREEN_MESSAGE_BUDGET = 2, AGENT_ERROR_CHARS = 1200, RAW_TYPE_LIMIT = 500, RAW_SCREEN_LINES = 12, HELP_KEYS, helpText = () => HELP_KEYS.map((key) => escapeHtml(t(key))).join(`
 `), ALBUM_DEBOUNCE_MS = 2000, UNKNOWN_SIZE = 1, REFUSAL_KEYS, megabytes2 = (bytes) => `${Math.round(bytes / (1024 * 1024))} MB`;
@@ -14521,13 +15203,13 @@ var init_src2 = __esm(() => {
 });
 
 // packages/daemon/src/machine-identity.ts
-import os8 from "os";
+import os9 from "os";
 function resolveMachineIdentity(override) {
-  const hostname = os8.hostname();
+  const hostname = os9.hostname();
   return {
     name: slugifyMachineName(override && override.trim().length > 0 ? override : hostname),
     hostname,
-    addresses: collectAddresses(os8.networkInterfaces())
+    addresses: collectAddresses(os9.networkInterfaces())
   };
 }
 var init_machine_identity = __esm(() => {
@@ -14719,6 +15401,9 @@ class TelegramService {
       problems.push(t("doctor.noUser"));
     if (problems.length > 0)
       return { ok: false, problems };
+    const pollError = this.channel?.pollHealth();
+    if (pollError !== undefined)
+      problems.push(t("doctor.telegram.pollFailing", { reason: pollError.replace(/\s+/g, " ").slice(0, 160) }));
     const api = new FetchTelegramApi(s.botToken);
     const report = { ok: true, problems };
     try {
@@ -14759,7 +15444,7 @@ var init_telegram_service = __esm(() => {
 // packages/daemon/src/index.ts
 var exports_src = {};
 import { randomBytes as randomBytes3 } from "crypto";
-import fs24 from "fs";
+import fs25 from "fs";
 import net5 from "net";
 function isPidAlive(pid) {
   try {
@@ -14771,9 +15456,9 @@ function isPidAlive(pid) {
 }
 async function main() {
   ensureDataDirs();
-  if (fs24.existsSync(RUNTIME_FILE2)) {
+  if (fs25.existsSync(RUNTIME_FILE2)) {
     try {
-      const existing = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
+      const existing = JSON.parse(fs25.readFileSync(RUNTIME_FILE2, "utf8"));
       if (existing.pid !== process.pid && isPidAlive(existing.pid)) {
         log(`daemon already running (pid ${existing.pid}); exiting`);
         process.exit(0);
@@ -14796,7 +15481,7 @@ async function main() {
     version: productVersion(),
     startedAt: Date.now()
   };
-  fs24.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
+  fs25.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
   restrictFile(RUNTIME_FILE2);
   const config = new ConfigStore(defaultConfigStorePaths(CONFIG_DIR));
   if (config.loadError !== undefined)
@@ -14848,9 +15533,9 @@ async function main() {
     hookHost.stop();
     store.close();
     try {
-      const current = JSON.parse(fs24.readFileSync(RUNTIME_FILE2, "utf8"));
+      const current = JSON.parse(fs25.readFileSync(RUNTIME_FILE2, "utf8"));
       if (current.pid === process.pid)
-        fs24.rmSync(RUNTIME_FILE2);
+        fs25.rmSync(RUNTIME_FILE2);
     } catch {}
     process.exit(0);
   };
@@ -14869,12 +15554,9 @@ async function main() {
   });
   process.on("SIGINT", () => stop("SIGINT"));
   process.on("SIGTERM", () => stop("SIGTERM"));
-  process.on("uncaughtException", (err) => {
-    log(`uncaughtException: ${err.stack ?? String(err)}`);
-    stop("uncaughtException");
-  });
   log(`daemon started pid=${process.pid} config=${CONFIG_DIR} state=${STATE_DIR}`);
 }
+var crashGuards;
 var init_src3 = __esm(() => {
   init_src();
   init_config_migrate();
@@ -14887,7 +15569,12 @@ var init_src3 = __esm(() => {
   init_telegram_service();
   init_store();
   net5.setDefaultAutoSelectFamilyAttemptTimeout(3000);
-  main();
+  crashGuards = new ProcessCrashGuards({
+    log,
+    exit: (code2) => process.exit(code2)
+  });
+  crashGuards.install(process);
+  main().catch((reason) => crashGuards.startupFailed(reason));
 });
 
 // packages/daemon/src/pty-host.ts
@@ -15097,8 +15784,8 @@ var init_pty_host_main = __esm(() => {
 
 // packages/cli/src/index.ts
 init_src();
-import fs25 from "fs";
-import path23 from "path";
+import fs26 from "fs";
+import path25 from "path";
 
 // packages/cli/src/attach.ts
 import fs from "fs";
@@ -15517,11 +16204,11 @@ ${bold(t(state.promptKey))} ${dim("[yes]")} `);
   const finished = advance({ ...state, kind: "review", step: "review" }, "");
   if (!("done" in finished))
     return { saved: false };
-  for (const [path3, value] of finished.done.settings) {
-    await client.call("config.set", { path: path3, value });
+  for (const [path4, value] of finished.done.settings) {
+    await client.call("config.set", { path: path4, value });
   }
-  for (const [path3, value] of finished.done.secrets) {
-    await client.call("config.set", { path: path3, value });
+  for (const [path4, value] of finished.done.secrets) {
+    await client.call("config.set", { path: path4, value });
   }
   stdout.write(`
 ${green("\u2713")} ${t("wizard.saved")}
@@ -15559,10 +16246,202 @@ function describeHealth(health) {
 // packages/cli/src/client.ts
 init_src();
 import { spawn } from "child_process";
-import fs2 from "fs";
+import fs3 from "fs";
 import net from "net";
-import path3 from "path";
+import path5 from "path";
 import { setTimeout as delay } from "timers/promises";
+
+// packages/cli/src/service-manager.ts
+init_src();
+import { spawnSync } from "child_process";
+import fs2 from "fs";
+import os3 from "os";
+import path4 from "path";
+
+class ServiceCommandError extends Error {
+  invocation;
+  result;
+  constructor(invocation, result) {
+    super(result.stderr.trim() || result.stdout.trim() || `${invocation.command} exited ${result.status}`);
+    this.invocation = invocation;
+    this.result = result;
+    this.name = "ServiceCommandError";
+  }
+}
+var defaultRun = ({ command, args }) => {
+  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
+  };
+};
+function writeAtomic(file, contents) {
+  fs2.mkdirSync(path4.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp`;
+  try {
+    fs2.writeFileSync(tmp, contents, { mode: 384 });
+    fs2.renameSync(tmp, file);
+    if (process.platform !== "win32")
+      fs2.chmodSync(file, 384);
+  } catch (err) {
+    try {
+      fs2.rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+function utf16Xml(contents) {
+  return Buffer.concat([Buffer.from([255, 254]), Buffer.from(contents, "utf16le")]);
+}
+function utf8Script(contents) {
+  return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(contents, "utf8")]);
+}
+
+class ServiceManager {
+  options;
+  definition;
+  run;
+  uid;
+  constructor(options) {
+    this.options = options;
+    this.run = options.run ?? defaultRun;
+    this.uid = options.uid ?? process.getuid?.();
+    this.definition = serviceDefinition({
+      platform: options.platform,
+      launch: options.launch,
+      homeDir: options.homeDir,
+      stateDir: options.stateDir,
+      ...options.userId ? { userId: options.userId } : {},
+      ...options.environment ? { environment: options.environment } : {}
+    });
+  }
+  install() {
+    fs2.mkdirSync(path4.join(this.options.stateDir, "logs"), { recursive: true, mode: 448 });
+    for (const companion of this.definition.companionFiles ?? []) {
+      writeAtomic(companion.file, this.definition.kind === "task-scheduler" ? utf8Script(companion.contents) : companion.contents);
+    }
+    writeAtomic(this.definition.file, this.definition.kind === "task-scheduler" ? utf16Xml(this.definition.contents) : this.definition.contents);
+    if (this.definition.kind === "systemd") {
+      this.must({ command: "systemctl", args: ["--user", "daemon-reload"] });
+      this.must({ command: "systemctl", args: ["--user", "enable", SYSTEMD_SERVICE] });
+    } else if (this.definition.kind === "launchd") {
+      this.must({ command: "launchctl", args: ["enable", this.launchdTarget()] });
+    } else {
+      this.must({ command: "schtasks.exe", args: ["/Create", "/TN", WINDOWS_TASK, "/XML", this.definition.file, "/F"] });
+    }
+  }
+  start() {
+    if (this.definition.kind === "systemd") {
+      this.must({ command: "systemctl", args: ["--user", "start", SYSTEMD_SERVICE] });
+    } else if (this.definition.kind === "launchd") {
+      const target = this.launchdTarget();
+      const loaded = this.run({ command: "launchctl", args: ["print", target] }).status === 0;
+      this.must(loaded ? { command: "launchctl", args: ["kickstart", target] } : { command: "launchctl", args: ["bootstrap", `gui/${this.requireUid()}`, this.definition.file] });
+    } else {
+      this.must({ command: "schtasks.exe", args: ["/Run", "/TN", WINDOWS_TASK] });
+    }
+  }
+  status() {
+    if (this.definition.kind === "systemd") {
+      return {
+        kind: this.definition.kind,
+        installed: fs2.existsSync(this.definition.file),
+        active: this.run({ command: "systemctl", args: ["--user", "is-active", "--quiet", SYSTEMD_SERVICE] }).status === 0
+      };
+    }
+    if (this.definition.kind === "launchd") {
+      return {
+        kind: this.definition.kind,
+        installed: fs2.existsSync(this.definition.file),
+        active: this.run({ command: "launchctl", args: ["print", this.launchdTarget()] }).status === 0
+      };
+    }
+    const installed = this.run({ command: "schtasks.exe", args: ["/Query", "/TN", WINDOWS_TASK] }).status === 0;
+    const active = installed && this.run({
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `if ((Get-ScheduledTask -TaskName '${WINDOWS_TASK}').State -eq 'Running') { exit 0 } else { exit 1 }`
+      ]
+    }).status === 0;
+    return { kind: this.definition.kind, installed, active };
+  }
+  uninstall() {
+    if (this.definition.kind === "systemd") {
+      this.run({ command: "systemctl", args: ["--user", "disable", SYSTEMD_SERVICE] });
+      fs2.rmSync(this.definition.file, { force: true });
+      this.must({ command: "systemctl", args: ["--user", "daemon-reload"] });
+    } else if (this.definition.kind === "launchd") {
+      this.run({ command: "launchctl", args: ["disable", this.launchdTarget()] });
+      fs2.rmSync(this.definition.file, { force: true });
+    } else {
+      this.run({ command: "schtasks.exe", args: ["/Delete", "/TN", WINDOWS_TASK, "/F"] });
+      fs2.rmSync(this.definition.file, { force: true });
+    }
+    for (const companion of this.definition.companionFiles ?? [])
+      fs2.rmSync(companion.file, { force: true });
+  }
+  must(command) {
+    const result = this.run(command);
+    if (result.status !== 0)
+      throw new ServiceCommandError(command, result);
+  }
+  requireUid() {
+    if (this.uid === undefined)
+      throw new Error("launchd requires the current uid");
+    return this.uid;
+  }
+  launchdTarget() {
+    return `gui/${this.requireUid()}/${LAUNCHD_LABEL}`;
+  }
+}
+function windowsUserId(run = defaultRun) {
+  const command = {
+    command: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "[System.Security.Principal.WindowsIdentity]::GetCurrent().Name"
+    ]
+  };
+  const result = run(command);
+  const value = result.stdout.trim();
+  if (result.status !== 0 || value === "")
+    throw new ServiceCommandError(command, result);
+  return value;
+}
+function startInstalledService(manager) {
+  if (!manager.status().installed)
+    return false;
+  manager.start();
+  return true;
+}
+function currentServiceManager(run = defaultRun) {
+  const paths = resolvePaths(currentPathEnv());
+  const environment = {};
+  if (process.env["AXTERM_CONFIG_DIR"] === paths.configDir)
+    environment["AXTERM_CONFIG_DIR"] = paths.configDir;
+  if (process.env["AXTERM_STATE_DIR"] === paths.stateDir)
+    environment["AXTERM_STATE_DIR"] = paths.stateDir;
+  if (process.env["AXTERM_RUNTIME_DIR"] === paths.runtimeDir)
+    environment["AXTERM_RUNTIME_DIR"] = paths.runtimeDir;
+  return new ServiceManager({
+    platform: process.platform,
+    homeDir: os3.homedir(),
+    stateDir: paths.stateDir,
+    launch: daemonLaunch({ execPath: process.execPath, mainScript: Bun.main }),
+    ...process.getuid ? { uid: process.getuid() } : {},
+    ...process.platform === "win32" ? { userId: windowsUserId(run) } : {},
+    ...Object.keys(environment).length > 0 ? { environment } : {},
+    run
+  });
+}
+
+// packages/cli/src/client.ts
 var RUNTIME_FILE = resolvePaths(currentPathEnv()).runtimeFile;
 
 class RpcClient {
@@ -15648,7 +16527,7 @@ class RpcClient {
 }
 function readRuntime() {
   try {
-    const runtime = JSON.parse(fs2.readFileSync(RUNTIME_FILE, "utf8"));
+    const runtime = JSON.parse(fs3.readFileSync(RUNTIME_FILE, "utf8"));
     process.kill(runtime.pid, 0);
     return runtime;
   } catch {
@@ -15667,11 +16546,14 @@ async function tryConnect() {
     return;
   }
 }
+function connectDaemonIfRunning() {
+  return tryConnect();
+}
 function daemonEnv(cwd, env) {
   const files = [];
   for (const name of dotenvCandidates(env["NODE_ENV"])) {
     try {
-      files.push(parseDotenv(fs2.readFileSync(path3.join(cwd, name), "utf8")));
+      files.push(parseDotenv(fs3.readFileSync(path5.join(cwd, name), "utf8")));
     } catch {}
   }
   return scrubDotenvKeys(env, files);
@@ -15680,14 +16562,26 @@ async function ensureDaemon() {
   const existing = await tryConnect();
   if (existing)
     return existing;
-  const launch = daemonLaunch({ execPath: process.execPath, mainScript: Bun.main });
-  const child = spawn(launch.command, launch.args, {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-    env: daemonEnv(process.cwd(), process.env)
-  });
-  child.unref();
+  let supervised = false;
+  try {
+    supervised = startInstalledService(currentServiceManager());
+  } catch (err) {
+    if (err instanceof ServiceCommandError) {
+      const command = [err.invocation.command, ...err.invocation.args].join(" ");
+      throw new Error(t("cli.service.commandFailed", { command, error: err.message }));
+    }
+    throw err;
+  }
+  if (!supervised) {
+    const launch = daemonLaunch({ execPath: process.execPath, mainScript: Bun.main });
+    const child = spawn(launch.command, launch.args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: daemonEnv(process.cwd(), process.env)
+    });
+    child.unref();
+  }
   const deadline = Date.now() + 15000;
   while (Date.now() < deadline) {
     await delay(300);
@@ -15695,12 +16589,12 @@ async function ensureDaemon() {
     if (client)
       return client;
   }
-  throw new Error(t("cli.daemon.notReady", { log: path3.join(resolvePaths(currentPathEnv()).logDir, "daemon.log") }));
+  throw new Error(t("cli.daemon.notReady", { log: path5.join(resolvePaths(currentPathEnv()).logDir, "daemon.log") }));
 }
 
 // packages/cli/src/hook-bridge.ts
 init_src();
-import fs3 from "fs";
+import fs4 from "fs";
 var POST_TIMEOUT_MS = 1500;
 function isCodexApproval(agent, body) {
   if (agent !== "codex")
@@ -15753,7 +16647,7 @@ function currentEndpoint() {
   if (file === undefined)
     return;
   try {
-    return parseHookEndpoint(fs3.readFileSync(file, "utf8"));
+    return parseHookEndpoint(fs4.readFileSync(file, "utf8"));
   } catch {
     return;
   }
@@ -15761,8 +16655,8 @@ function currentEndpoint() {
 
 // packages/cli/src/mcp-server.ts
 init_src();
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path6 from "path";
 var ASK_TIMEOUT_MS = 10 * 60000;
 var POST_TIMEOUT_MS2 = 5000;
 var TOOLS = [
@@ -15878,7 +16772,7 @@ class McpServer {
     const contextFile = this.io.env[MCP_CONTEXT_ENV];
     if (contextFile !== undefined) {
       try {
-        const context = JSON.parse(fs4.readFileSync(contextFile, "utf8"));
+        const context = JSON.parse(fs5.readFileSync(contextFile, "utf8"));
         if (context.port && context.token && context.sessionId) {
           return {
             url: `http://127.0.0.1:${context.port}`,
@@ -15923,7 +16817,7 @@ class McpServer {
     const target = this.target();
     if (!target)
       return { text: "axterm is not reachable from this session", isError: true };
-    const resolved = path4.isAbsolute(file) ? file : path4.resolve(this.io.cwd, file);
+    const resolved = path6.isAbsolute(file) ? file : path6.resolve(this.io.cwd, file);
     const caption = typeof args["caption"] === "string" ? args["caption"] : undefined;
     const res = await this.post("/hook/attach", { sessionId: target.sessionId, launchToken: target.launchToken, path: resolved, caption }, POST_TIMEOUT_MS2);
     if (!res)
@@ -16033,15 +16927,15 @@ function runMcpServer() {
 
 // packages/cli/src/update.ts
 init_src();
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 // packages/cli/package.json
 var package_default = {
   name: "@layorixinc/axterm",
-  version: "0.6.0",
+  version: "0.6.1",
   type: "module",
   bin: {
     axterm: "dist/cli.js"
@@ -16115,13 +17009,13 @@ function assetName(platform, arch, isMusl) {
 function usesMusl() {
   if (process.platform !== "linux")
     return false;
-  if (fs5.existsSync("/etc/alpine-release"))
+  if (fs6.existsSync("/etc/alpine-release"))
     return true;
-  const ldd = spawnSync("ldd", ["--version"], { encoding: "utf8" });
+  const ldd = spawnSync2("ldd", ["--version"], { encoding: "utf8" });
   return `${ldd.stdout ?? ""}${ldd.stderr ?? ""}`.toLowerCase().includes("musl");
 }
 function firstLine(command, args) {
-  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+  const result = spawnSync2(command, args, { encoding: "utf8", windowsHide: true });
   if (result.status !== 0)
     return;
   return result.stdout?.trim().split(/\r?\n/)[0]?.trim() || undefined;
@@ -16129,7 +17023,7 @@ function firstLine(command, args) {
 function detectOrigin(execPath) {
   const resolved = (() => {
     try {
-      return fs5.realpathSync(execPath);
+      return fs6.realpathSync(execPath);
     } catch {
       return execPath;
     }
@@ -16154,7 +17048,7 @@ function npmGlobalBin() {
   const prefix = firstLine("npm", ["prefix", "-g"]);
   if (prefix === undefined)
     return;
-  return process.platform === "win32" ? prefix : path5.join(prefix, "bin");
+  return process.platform === "win32" ? prefix : path7.join(prefix, "bin");
 }
 async function download(url, into) {
   const response = await fetch(url, { signal: AbortSignal.timeout(600000) });
@@ -16171,7 +17065,7 @@ function checksumFor(sums, asset) {
   return;
 }
 function sha256(file) {
-  return createHash2("sha256").update(fs5.readFileSync(file)).digest("hex");
+  return createHash2("sha256").update(fs6.readFileSync(file)).digest("hex");
 }
 function ask2(question) {
   if (stdin2.isTTY !== true)
@@ -16218,8 +17112,8 @@ async function runUpdate(client, current, options) {
   }
   const asset = assetName(process.platform, process.arch, usesMusl());
   const base = `${RELEASES}/v${latest.version}`;
-  const staging = fs5.mkdtempSync(`${process.execPath}.update-`);
-  const downloaded = path5.join(staging, asset);
+  const staging = fs6.mkdtempSync(`${process.execPath}.update-`);
+  const downloaded = path7.join(staging, asset);
   try {
     console.log(t("cli.update.downloading", { asset }));
     await download(`${base}/${asset}`, downloaded);
@@ -16232,8 +17126,8 @@ async function runUpdate(client, current, options) {
       return;
     }
     if (process.platform !== "win32")
-      fs5.chmodSync(downloaded, 493);
-    const reported = spawnSync(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
+      fs6.chmodSync(downloaded, 493);
+    const reported = spawnSync2(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
     if (reported !== latest.version) {
       console.error(t("cli.update.wrongVersion", { got: reported ?? "nothing", want: latest.version }));
       process.exitCode = 1;
@@ -16265,14 +17159,14 @@ async function runUpdate(client, current, options) {
     if (plan.stale > 0)
       console.log(t("cli.update.staleDaemon", { count: plan.stale }));
     for (const id of plan.resume) {
-      const result = spawnSync(process.execPath, ["resume", id, "--no-attach", "--no-setup"], { encoding: "utf8" });
+      const result = spawnSync2(process.execPath, ["resume", id, "--no-attach", "--no-setup"], { encoding: "utf8" });
       if (result.status === 0)
         console.log(t("cli.update.restored", { id }));
       else
         console.log(t("cli.update.restoreFailed", { id, reason: (result.stderr ?? "").trim() || "unknown" }));
     }
   } finally {
-    fs5.rmSync(staging, { recursive: true, force: true });
+    fs6.rmSync(staging, { recursive: true, force: true });
   }
 }
 function applySwap(target, downloaded) {
@@ -16281,20 +17175,88 @@ function applySwap(target, downloaded) {
   try {
     for (const step of steps) {
       if (step.op === "chmod")
-        fs5.chmodSync(step.from, 493);
+        fs6.chmodSync(step.from, 493);
       else if (step.op === "backup") {
-        fs5.renameSync(step.from, step.to);
+        fs6.renameSync(step.from, step.to);
         backup = step.to;
       } else
-        fs5.renameSync(step.from, step.to);
+        fs6.renameSync(step.from, step.to);
     }
   } catch (err) {
-    if (backup !== undefined && !fs5.existsSync(target))
-      fs5.renameSync(backup, target);
+    if (backup !== undefined && !fs6.existsSync(target))
+      fs6.renameSync(backup, target);
     throw err;
   }
 }
 
+// packages/cli/src/service-command.ts
+init_src();
+import { setTimeout as delay2 } from "timers/promises";
+var SERVICE_WAIT_MS = 15000;
+var SERVICE_POLL_MS = 200;
+async function waitForDaemon(deps, running) {
+  const sleep = deps.sleep ?? ((ms) => delay2(ms));
+  const now = deps.now ?? Date.now;
+  const deadline = now() + SERVICE_WAIT_MS;
+  for (;; ) {
+    const connected = await deps.connect();
+    if (running && connected !== undefined)
+      return connected;
+    connected?.close();
+    if (!running && connected === undefined)
+      return;
+    if (now() >= deadline)
+      throw new Error(t("cli.service.notReady"));
+    await sleep(SERVICE_POLL_MS);
+  }
+}
+function localizedStatus(status) {
+  return t("cli.service.status", {
+    kind: status.kind,
+    installed: t(status.installed ? "cli.service.yes" : "cli.service.no"),
+    active: t(status.active ? "cli.service.yes" : "cli.service.no")
+  });
+}
+function localizeCommandError(err) {
+  if (err instanceof ServiceCommandError) {
+    const command = [err.invocation.command, ...err.invocation.args].join(" ");
+    throw new Error(t("cli.service.commandFailed", { command, error: err.message }));
+  }
+  throw err;
+}
+async function runServiceCommand(subcommand, deps) {
+  const write = deps.write ?? console.log;
+  try {
+    if (subcommand === "status") {
+      write(localizedStatus(deps.manager.status()));
+      return;
+    }
+    if (subcommand === "uninstall") {
+      deps.manager.uninstall();
+      write(t("cli.service.uninstalled"));
+      return;
+    }
+    if (subcommand !== "install")
+      throw new Error(t("cli.usage.service"));
+    deps.manager.install();
+    const existing = await deps.connect();
+    if (existing !== undefined) {
+      try {
+        await existing.call("daemon.stop");
+      } finally {
+        existing.close();
+      }
+      await waitForDaemon(deps, false);
+    }
+    deps.manager.start();
+    const ready = await waitForDaemon(deps, true);
+    ready?.close();
+    write(t("cli.service.installed", { kind: deps.manager.definition.kind }));
+  } catch (err) {
+    localizeCommandError(err);
+  }
+}
+
 // packages/cli/src/index.ts
 var VERSION = package_default.version;
 var VALUE_FLAGS = new Set([
@@ -16363,7 +17325,7 @@ function printSessionTable(sessions) {
     console.log(row.map((cell, col) => cell.padEnd(widths[col])).join("  "));
   }
 }
-var realPath = (target) => fs25.realpathSync.native(target);
+var realPath = (target) => fs26.realpathSync.native(target);
 function scopedHere(sessions) {
   return sessionsInScope(sessions, process.cwd(), realPath);
 }
@@ -16376,7 +17338,7 @@ var help = () => t("cli.help");
 function readDotEnv(file = ".env") {
   const out = {};
   try {
-    for (const line of fs25.readFileSync(file, "utf8").split(/\r?\n/)) {
+    for (const line of fs26.readFileSync(file, "utf8").split(/\r?\n/)) {
       const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m)
         out[m[1]] = m[2].trim();
@@ -16387,7 +17349,7 @@ function readDotEnv(file = ".env") {
 function configuredLocale() {
   try {
     const file = resolvePaths(currentPathEnv()).configFile;
-    const raw = JSON.parse(fs25.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs26.readFileSync(file, "utf8"));
     return typeof raw.locale === "string" ? raw.locale : undefined;
   } catch {
     return;
@@ -16424,6 +17386,13 @@ async function main2() {
     console.log(help());
     return;
   }
+  if (command === "service") {
+    await runServiceCommand(positional[0] ?? "status", {
+      manager: currentServiceManager(),
+      connect: connectDaemonIfRunning
+    });
+    return;
+  }
   const client = await ensureDaemon();
   const health = await client.call("config.health").catch(() => {
     return;
@@ -16538,12 +17507,10 @@ async function main2() {
         if (!id || indexArg === undefined)
           throw new Error(t("cli.usage.choose"));
         const index = Number(indexArg);
-        const answered = await client.call("session.choose", { id, index }).catch(async (err) => {
+        const answered = await client.call("session.choose", { id, index }).catch((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" };
+          throw new Error(t("cli.choose.daemonTooOld"));
         });
         console.log(t("cli.session.selected", { index: indexArg }));
         if (answered.answered === "onboarding")
@@ -16623,8 +17590,8 @@ async function main2() {
       case "project": {
         const sub = positional[0] ?? "list";
         if (sub === "add") {
-          const dir = positional[1] ? path23.resolve(positional[1]) : process.cwd();
-          const alias = positional[2] ?? path23.basename(dir);
+          const dir = positional[1] ? path25.resolve(positional[1]) : process.cwd();
+          const alias = positional[2] ?? path25.basename(dir);
           const projects = await client.call("project.add", {
             alias,
             path: dir