@layorixinc/axterm 0.1.0 → 0.4.0

package/dist/cli.js

@@ -33,6 +33,136 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/core/src/mcp-config.ts
+function mcpServerEntry(launch, contextPath) {
+  return {
+    command: launch.command,
+    args: [...launch.args],
+    ...contextPath === undefined ? {} : { env: { [MCP_CONTEXT_ENV]: contextPath } }
+  };
+}
+function claudeMcpConfig(launch, contextPath) {
+  return JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: mcpServerEntry(launch, contextPath) } }, null, 2);
+}
+function tomlLiteral(value) {
+  if (value.includes("'")) {
+    throw new Error(`cannot pass a path containing a single quote to codex: ${value}`);
+  }
+  return `'${value}'`;
+}
+function codexMcpArgs(launch, contextPath) {
+  const args = launch.args.map(tomlLiteral).join(",");
+  return [
+    "-c",
+    `mcp_servers.${MCP_SERVER_NAME}.command=${tomlLiteral(launch.command)}`,
+    "-c",
+    `mcp_servers.${MCP_SERVER_NAME}.args=[${args}]`,
+    ...contextPath === undefined ? [] : ["-c", `mcp_servers.${MCP_SERVER_NAME}.env={${MCP_CONTEXT_ENV}=${tomlLiteral(contextPath)}}`]
+  ];
+}
+var MCP_SERVER_NAME = "axterm", MCP_CONTEXT_ENV = "AXTERM_MCP_CONTEXT";
+
+// packages/core/src/agent-launch.ts
+function uuidFromSessionId(sessionId) {
+  const hex = sessionId.replace(/-/g, "");
+  if (hex.length !== 32)
+    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function withAppServer(argv, url) {
+  const out = [];
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--remote") {
+      i++;
+      continue;
+    }
+    out.push(argv[i]);
+  }
+  if (url === undefined || out.length === 0)
+    return out;
+  return [out[0], "--remote", url, ...out.slice(1)];
+}
+function buildAgentCommand(input) {
+  const extra = [...input.extraArgs ?? []];
+  if (input.agent === "claude") {
+    return [
+      "claude",
+      "--settings",
+      input.claudeSettingsPath,
+      ...input.mcpConfigPath === undefined ? [] : ["--mcp-config", input.mcpConfigPath],
+      "--session-id",
+      uuidFromSessionId(input.sessionId),
+      ...extra
+    ];
+  }
+  if (input.agent === "gemini") {
+    return [
+      "gemini",
+      "--session-id",
+      input.sessionId,
+      ...extra
+    ];
+  }
+  if (input.agent === "codex") {
+    return [
+      "codex",
+      ...input.appServerUrl === undefined ? [] : ["--remote", input.appServerUrl],
+      ...input.mcpLaunch === undefined ? [] : codexMcpArgs(input.mcpLaunch, input.mcpContextPath),
+      ...extra
+    ];
+  }
+  return ["omp", "--extension", input.extensionPath, ...extra];
+}
+function resolveAgentArgs(input) {
+  const approve = input.autoApprove ?? input.autoApproveConfigured;
+  const layered = [
+    ...approve === true ? input.bypass ?? [] : [],
+    ...input.configured ?? [],
+    ...input.requested ?? []
+  ];
+  const groups = [];
+  for (const token of layered) {
+    if (token.startsWith("-"))
+      groups.push({ flag: token, tokens: [token] });
+    else if (groups.length > 0)
+      groups[groups.length - 1].tokens.push(token);
+    else
+      groups.push({ flag: undefined, tokens: [token] });
+  }
+  const lastIndex = new Map;
+  groups.forEach((group, index) => {
+    if (group.flag !== undefined)
+      lastIndex.set(group.flag, index);
+  });
+  return groups.filter((group, index) => group.flag === undefined || lastIndex.get(group.flag) === index).flatMap((group) => group.tokens);
+}
+function buildAgentResumeCommand(input) {
+  if (input.agent === "claude") {
+    return [
+      "claude",
+      "--settings",
+      input.claudeSettingsPath,
+      "--resume",
+      uuidFromSessionId(input.sessionId),
+      ...input.extraArgs ?? []
+    ];
+  }
+  if (input.agent === "gemini") {
+    return ["gemini", "--resume", input.sessionId, ...input.extraArgs ?? []];
+  }
+  return buildAgentCommand(input);
+}
+function isAgentId(value) {
+  return AGENT_IDS.includes(value);
+}
+function supportedAgents() {
+  return AGENT_IDS;
+}
+var AGENT_IDS;
+var init_agent_launch = __esm(() => {
+  AGENT_IDS = ["omp", "claude", "codex", "gemini"];
+});
+
 // packages/core/src/activity.ts
 function shouldStream(kind, settings) {
   if (!settings.enabled)
@@ -41,6 +171,8 @@ function shouldStream(kind, settings) {
     return settings.thinking;
   if (kind === "tool")
     return settings.tools;
+  if (kind === "reply")
+    return settings.replies;
   return settings.toolResults;
 }
 function clipText(text, maxChars) {
@@ -147,7 +279,8 @@ var init_activity = __esm(() => {
   MARKERS = {
     thinking: "\uD83E\uDDE0",
     tool: "\uD83D\uDD27",
-    toolResult: "\u21B3"
+    toolResult: "\u21B3",
+    reply: "\uD83D\uDCAC"
   };
 });
 
@@ -279,6 +412,7 @@ function resolveStreamConfig(file) {
     thinking: file?.thinking ?? DEFAULT_STREAM_CONFIG.thinking,
     tools: file?.tools ?? DEFAULT_STREAM_CONFIG.tools,
     toolResults: file?.toolResults ?? DEFAULT_STREAM_CONFIG.toolResults,
+    replies: file?.replies ?? DEFAULT_STREAM_CONFIG.replies,
     intervalMs: file?.intervalMs ?? DEFAULT_STREAM_CONFIG.intervalMs,
     maxChars: file?.maxChars ?? DEFAULT_STREAM_CONFIG.maxChars
   };
@@ -365,12 +499,30 @@ function parseConfig(raw) {
   }
   const defaults = raw["defaults"];
   if (isRecord(defaults)) {
-    checkKeys(defaults, ["agent", "shell"], "defaults.", errors);
+    checkKeys(defaults, ["agent", "shell", "autoApprove", "agentArgs"], "defaults.", errors);
     const agent = defaults["agent"];
     const shell = defaults["shell"];
+    const rawArgs = defaults["agentArgs"];
+    const agentArgs = {};
+    if (isRecord(rawArgs)) {
+      for (const [id, value] of Object.entries(rawArgs)) {
+        if (Array.isArray(value) && value.every((part) => typeof part === "string"))
+          agentArgs[id] = value;
+        else
+          errors.push(`defaults.agentArgs.${id} must be a list of strings`);
+      }
+    } else if (rawArgs !== undefined) {
+      errors.push("defaults.agentArgs must be an object keyed by agent");
+    }
+    const autoApprove = defaults["autoApprove"];
+    if (autoApprove !== undefined && typeof autoApprove !== "boolean") {
+      errors.push("defaults.autoApprove must be true or false");
+    }
     config.defaults = {
       ...typeof agent === "string" ? { agent } : {},
-      ...typeof shell === "string" ? { shell } : {}
+      ...typeof shell === "string" ? { shell } : {},
+      ...typeof autoApprove === "boolean" ? { autoApprove } : {},
+      ...Object.keys(agentArgs).length > 0 ? { agentArgs } : {}
     };
   }
   const projects = raw["projects"];
@@ -404,9 +556,9 @@ function parseConfig(raw) {
       }
       const stream = telegram["stream"];
       if (isRecord(stream)) {
-        checkKeys(stream, ["enabled", "thinking", "tools", "toolResults", "intervalMs", "maxChars"], "channels.telegram.stream.", errors);
+        checkKeys(stream, ["enabled", "thinking", "tools", "toolResults", "replies", "intervalMs", "maxChars"], "channels.telegram.stream.", errors);
         const streamEntry = {};
-        for (const key of ["enabled", "thinking", "tools", "toolResults", "intervalMs", "maxChars"]) {
+        for (const key of ["enabled", "thinking", "tools", "toolResults", "replies", "intervalMs", "maxChars"]) {
           const value = stream[key];
           if (value === undefined)
             continue;
@@ -445,21 +597,28 @@ function getConfigValue(config, dottedPath) {
   return cursor;
 }
 function coerce(input, type) {
+  if (Array.isArray(input))
+    return type === "string[]" && input.length > 0 ? [...input] : undefined;
+  const text = input;
   if (type === "string")
-    return input;
+    return text;
   if (type === "number") {
-    const value = Number(input);
+    const value = Number(text);
     return Number.isFinite(value) ? value : undefined;
   }
   if (type === "boolean") {
-    if (/^(true|yes|on|1)$/i.test(input))
+    if (/^(true|yes|on|1)$/i.test(text))
       return true;
-    if (/^(false|no|off|0)$/i.test(input))
+    if (/^(false|no|off|0)$/i.test(text))
       return false;
     return;
   }
-  const parts = input.split(",").map((p) => Number(p.trim()));
-  return parts.every((p) => Number.isFinite(p)) ? parts : undefined;
+  if (type === "string[]") {
+    const parts = text.trim().split(/\s+/).filter((part) => part !== "");
+    return parts.length > 0 ? parts : undefined;
+  }
+  const numbers = text.split(",").map((part) => Number(part.trim()));
+  return numbers.every((part) => Number.isFinite(part)) ? numbers : undefined;
 }
 function setConfigValue(config, dottedPath, rawValue) {
   const type = FIELDS[dottedPath];
@@ -468,8 +627,10 @@ function setConfigValue(config, dottedPath, rawValue) {
     return { error: `unknown setting "${dottedPath}"${suggestion ? ` \u2014 did you mean "${suggestion}"?` : ""}` };
   }
   const value = coerce(rawValue, type);
-  if (value === undefined)
-    return { error: `"${rawValue}" is not a valid ${type} for ${dottedPath}` };
+  if (value === undefined) {
+    const shown = Array.isArray(rawValue) ? rawValue.join(" ") : rawValue;
+    return { error: `"${shown}" is not a valid ${type} for ${dottedPath}` };
+  }
   const next = structuredClone(config);
   const segments = dottedPath.split(".");
   let cursor = next;
@@ -515,6 +676,7 @@ function resolveEnvRefs(config, env) {
 }
 var CONFIG_VERSION = 1, DEFAULT_CONFIG, DEFAULT_STREAM_CONFIG, DEFAULT_INBOUND_CONFIG, FIELDS, SECRET_SUFFIXES, ENV_REF;
 var init_config_schema = __esm(() => {
+  init_agent_launch();
   init_channel_spi();
   DEFAULT_CONFIG = {
     version: CONFIG_VERSION,
@@ -526,6 +688,7 @@ var init_config_schema = __esm(() => {
     thinking: false,
     tools: true,
     toolResults: false,
+    replies: false,
     intervalMs: 1e4,
     maxChars: 300
   };
@@ -534,10 +697,12 @@ var init_config_schema = __esm(() => {
     maxBytes: TELEGRAM_CAPABILITIES.attachments.maxBytes
   };
   FIELDS = {
+    ...Object.fromEntries(supportedAgents().map((agent) => [`defaults.agentArgs.${agent}`, "string[]"])),
     locale: "string",
     "machine.name": "string",
     "defaults.agent": "string",
     "defaults.shell": "string",
+    "defaults.autoApprove": "boolean",
     "channels.telegram.enabled": "boolean",
     "channels.telegram.groupId": "number",
     "channels.telegram.allowUserIds": "number[]",
@@ -548,6 +713,7 @@ var init_config_schema = __esm(() => {
     "channels.telegram.stream.thinking": "boolean",
     "channels.telegram.stream.tools": "boolean",
     "channels.telegram.stream.toolResults": "boolean",
+    "channels.telegram.stream.replies": "boolean",
     "channels.telegram.stream.intervalMs": "number",
     "channels.telegram.stream.maxChars": "number",
     "channels.telegram.inbound.enabled": "boolean",
@@ -664,8 +830,12 @@ var init_i18n = __esm(() => {
 usage:
   axterm run [--cwd DIR] [--name NAME] [--shell pwsh|powershell|cmd|bash|zsh]
              [--no-attach] [--cmd "raw command"] [-- <extra agent args>]
+             [--auto-approve | --no-auto-approve]   let the agent act without asking,
+                                   overriding defaults.autoApprove for this session only
   axterm list [--all]              sessions started in this folder; --all for every one
-  axterm attach <id> [--host-status orca]   detach: Ctrl+X Ctrl+X (or F12 / Ctrl+])
+  axterm attach <id>|--last [--all] [--host-status orca]
+                                   --last: the newest live session here, for when the id is gone
+                                   detach: Ctrl+X Ctrl+X (or F12 / Ctrl+])
                                    the host terminal title always reflects agent status;
                                    --host-status orca also reports full status to the pane
   axterm esc <id>                  send ESC (interrupt)
@@ -684,9 +854,11 @@ usage:
   axterm fanout --count 3 [--prefix try] "prompt"
   axterm worktree list|rm <branch> [--force]
   axterm diff <id> [--base REF]
-  axterm telegram link|doctor|status
+  axterm telegram link|doctor|status|discover
+                                   discover lists the group and user ids your bot can see
   axterm setup                     interactive configuration (runs automatically on first use)
   axterm doctor                    diagnose the silent failures: agent binaries, hook configs, codex trust, the bridge
+  axterm quota                     how much of each agent's rate limit is spent, from the agent's own records
   axterm config list|get <path>|set <path> <v>|unset <path>|path|import-env [file]
 
 locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
@@ -697,7 +869,9 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.sessions.removed": "removed {count} session(s)",
     "cli.sessions.noneExited": "no exited sessions to remove",
     "cli.session.removeFailed": "could not remove {id}: {error}",
-    "cli.session.created": "created session {id} ({shell}, pid {pid})",
+    "cli.session.created": "created session {id} ({shell}, pid {pid}) \u2014 reattach with `axterm attach {id}`, or `axterm attach --last`",
+    "cli.attach.picked": "attaching to {id} ({name}), the most recent live session here",
+    "cli.attach.noRecent": "no live session here to reattach \u2014 `axterm list --all` shows every one",
     "cli.session.killed": "killed",
     "cli.session.sent": "sent",
     "cli.session.sentKey": "sent {key}",
@@ -725,7 +899,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.update.notBinary": "this axterm runs from source, so there is nothing to replace \u2014 use git pull",
     "cli.flag.needsValue": "--{flag} requires a value",
     "cli.key.unknown": "unknown key: {name}",
-    "cli.usage.attach": "usage: axterm attach <id>",
+    "cli.usage.attach": "usage: axterm attach <id>   (or `axterm attach --last`)",
     "cli.usage.send": "usage: axterm send [--raw] <id> <text...>",
     "cli.usage.screen": "usage: axterm screen <id>",
     "cli.usage.esc": "usage: axterm esc <id>",
@@ -738,14 +912,14 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.usage.diff": "usage: axterm diff <id> [--base REF]",
     "cli.usage.config": "usage: axterm config list|get|set|unset|path|import-env",
     "cli.usage.configGet": "usage: axterm config get <path> [--reveal]",
-    "cli.usage.configSet": "usage: axterm config set <path> <value>",
+    "cli.usage.configSet": "usage: axterm config set <path> <value>   (a value starting with - goes after `--`)",
     "cli.usage.configUnset": "usage: axterm config unset <path>",
     "cli.usage.project": "usage: axterm project add|list|rm",
     "cli.usage.projectRm": "usage: axterm project rm <alias>",
     "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.telegram": "usage: axterm telegram link|doctor|status",
+    "cli.usage.telegram": "usage: axterm telegram link|doctor|status|discover",
     "cli.usage.fanout": "usage: axterm fanout --count N <prompt>",
     "cli.config.set": "set {path}",
     "cli.config.unset": "unset {path}",
@@ -762,6 +936,13 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "cli.daemon.stopping": "daemon stopping",
     "cli.daemon.notReady": "daemon did not become ready within 15s (see {log})",
     "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.",
+    "cli.telegram.discoverChats": "groups this bot can see (use the id as --group):",
+    "cli.telegram.discoverUsers": "people it has seen (use the id as --user):",
+    "cli.telegram.topicsOff": "Topics are OFF \u2014 axterm needs them; enable Topics in the group settings",
+    "err.telegram.discoverWhileRunning": "the telegram channel is already running, and Telegram allows one reader per bot token \u2014 stop it with `axterm config set channels.telegram.enabled false` before discovering, or read the ids from `axterm telegram status`",
+    "err.telegram.noToken": "no bot token is configured \u2014 run `axterm setup` or pass --token",
     "tg.help.general.header": "axterm commands (General topic):",
     "tg.help.general.projects": "/projects \u2014 registered projects",
     "tg.help.general.new": "/new <project> [name] \u2014 new omp session",
@@ -770,7 +951,7 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.help.general.worktrees": "/worktrees <project> \xB7 /rm <project> <branch> [force]",
     "tg.help.general.sessions": "/sessions \u2014 session list",
     "tg.help.topic.header": "Inside a session topic, a plain message is delivered as a prompt.",
-    "tg.help.topic.commands": "/esc interrupt \xB7 /screen snapshot \xB7 /diff change summary \xB7 /resume continue the conversation \xB7 /kill stop",
+    "tg.help.topic.commands": "/esc interrupt \xB7 /screen snapshot \xB7 /diff change summary \xB7 /quota rate limits \xB7 /key & /type raw input \xB7 /resume continue the conversation \xB7 /kill stop",
     "tg.session.started": `\u25B6 Session {id} started
 {command}
 \uD83D\uDCC1 {cwd}`,
@@ -794,6 +975,15 @@ locale: set AXTERM_LANG=en|ko, or \`axterm config set locale ko\`
     "tg.shell.only": "(shell)",
     "tg.agent.failed": "\uD83D\uDED1 The agent could not finish this turn: {error}",
     "tg.agent.retry": "\u23F3 The agent is rate limited and will retry in {wait}: {error}",
+    "tg.raw.keysSent": "\u2328\uFE0F sent: {keys}",
+    "tg.raw.unknownKey": 'unknown key "{name}" \u2014 nothing was sent. Accepted: {keys}',
+    "tg.raw.typed": `\u2328\uFE0F typed (not submitted \u2014 /key enter to send):
+<pre>{screen}</pre>`,
+    "tg.raw.needText": "usage: /type <text> \u2014 written verbatim, without Enter. Then /key enter.",
+    "tg.raw.tooLong": "too long for raw input ({limit} characters max) \u2014 send it as an ordinary message instead",
+    "tg.agent.attempt": "\u26A0\uFE0F An attempt failed and the agent is retrying: {error}",
+    "tg.agent.stalled": `\u23F8\uFE0F No progress for {wait}. The agent has not said why \u2014 this is the last thing it printed:
+<pre>{screen}</pre>`,
     "tg.inbound.tooLarge": "\u26A0\uFE0F That file is larger than the {limit} limit \u2014 nothing was downloaded.",
     "tg.inbound.empty": "\u26A0\uFE0F That file is empty \u2014 nothing was downloaded.",
     "tg.inbound.noSession": "\u26A0\uFE0F Send the file inside a session topic \u2014 no session is bound to this one.",
@@ -869,6 +1059,15 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.telegram.ok": "telegram: connected",
     "doctor.telegram.off": "telegram: not running",
     "doctor.telegram.problems": "telegram: {problems}",
+    "quota.gauge": "{agent}: {percent}% of {window} used, resets in {resets}",
+    "quota.gaugeStale": "{agent}: {percent}% of {window} used, resets in {resets} (recorded {age} ago)",
+    "quota.gaugeElapsed": "{agent}: {percent}% of {window} used, and that window has already reset",
+    "quota.reached": "{agent}: the limit was reached \u2014 {percent}% of {window}, resets in {resets}",
+    "quota.event": "{agent}: hit its limit {age} ago \u2014 {text}",
+    "quota.eventNone": "{agent}: no limit reported (it records no percentage)",
+    "quota.noData": "{agent}: nothing recorded yet \u2014 run a turn first",
+    "quota.unsupported": "{agent}: reports no quota at all",
+    "cli.quota.none": "no agent on this machine reports a quota",
     "fanout.needCountOrBranches": "a branch count or a branch list is required",
     "fanout.needPrompt": "a prompt is required",
     "fanout.outOfRange": "must be between 1 and {max}",
@@ -892,11 +1091,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "health.telegram.noUsers": "Telegram is enabled but no user is allowed to control it",
     "wizard.prompt.locale": "Language",
     "wizard.prompt.machine": "Name for this machine (used to address it from a channel)",
-    "wizard.prompt.agent": "Default agent command",
+    "wizard.prompt.agent": "Default agent (extra flags go in defaults.agentArgs.<agent>)",
     "wizard.prompt.telegram": "Set up Telegram control now?",
     "wizard.prompt.telegramToken": "Bot token from @BotFather",
-    "wizard.prompt.telegramGroup": "Group id (negative, starts with -100)",
-    "wizard.prompt.telegramUsers": "Telegram user ids allowed to control axterm (comma separated)",
+    "wizard.prompt.agentApproval": "Let this agent act without asking for approval? It skips every permission prompt \u2014 convenient from a phone, and it means the agent may edit or run anything in the session's folder. Reversible with `axterm config set defaults.autoApprove false`, or for one session with `axterm run --no-auto-approve`.",
+    "wizard.prompt.telegramGroup": "Group id (negative, starts with -100; `axterm telegram discover` lists them)",
+    "wizard.prompt.telegramUsers": "Telegram user ids allowed to control axterm (comma separated; `axterm telegram discover` lists them)",
     "wizard.prompt.review": "Save this configuration?",
     "wizard.error.locale": "pick one of the offered languages",
     "wizard.error.machine": "letters, digits, dot, dash and underscore only",
@@ -926,8 +1126,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
 \uC0AC\uC6A9\uBC95:
   axterm run [--cwd \uD3F4\uB354] [--name \uC774\uB984] [--shell pwsh|powershell|cmd|bash|zsh]
              [--no-attach] [--cmd "\uC6D0\uC2DC \uBA85\uB839"] [-- <\uC5D0\uC774\uC804\uD2B8 \uCD94\uAC00 \uC778\uC790>]
+             [--auto-approve | --no-auto-approve]   \uC774 \uC138\uC158\uB9CC \uC2B9\uC778 \uC5C6\uC774 \uB3D9\uC791\uD558\uAC8C,
+                                   defaults.autoApprove \uB97C \uB36E\uC5B4\uC501\uB2C8\uB2E4
   axterm list [--all]              \uC774 \uD3F4\uB354\uC5D0\uC11C \uB9CC\uB4E0 \uC138\uC158. --all \uC740 \uC804\uCCB4
-  axterm attach <id> [--host-status orca]   \uBD84\uB9AC: Ctrl+X Ctrl+X (\uB610\uB294 F12 / Ctrl+])
+  axterm attach <id>|--last [--all] [--host-status orca]
+                                   --last: \uC774 \uD3F4\uB354\uC758 \uAC00\uC7A5 \uCD5C\uADFC \uC0B4\uC544\uC788\uB294 \uC138\uC158 (id\uB97C \uC783\uC5C8\uC744 \uB54C)
+                                   \uBD84\uB9AC: Ctrl+X Ctrl+X (\uB610\uB294 F12 / Ctrl+])
                                    \uD638\uC2A4\uD2B8 \uD130\uBBF8\uB110 \uC81C\uBAA9\uC740 \uD56D\uC0C1 \uC5D0\uC774\uC804\uD2B8 \uC0C1\uD0DC\uB97C \uBC18\uC601\uD55C\uB2E4;
                                    --host-status orca \uB294 \uD32C\uC5D0\uB3C4 \uC804\uCCB4 \uC0C1\uD0DC\uB97C \uBCF4\uACE0\uD55C\uB2E4
   axterm esc <id>                  ESC \uC804\uC1A1 (\uC911\uB2E8)
@@ -946,9 +1150,11 @@ usage: /fanout <project> <count|branches> <prompt>`,
   axterm fanout --count 3 [--prefix try] "\uD504\uB86C\uD504\uD2B8"
   axterm worktree list|rm <\uBE0C\uB79C\uCE58> [--force]
   axterm diff <id> [--base REF]
-  axterm telegram link|doctor|status
+  axterm telegram link|doctor|status|discover
+                                   discover \u2014 \uBD07\uC774 \uBCFC \uC218 \uC788\uB294 \uADF8\uB8F9\xB7\uC0AC\uC6A9\uC790 id \uBAA9\uB85D
   axterm setup                     \uB300\uD654\uD615 \uC124\uC815 (\uCD5C\uCD08 \uC2E4\uD589 \uC2DC \uC790\uB3D9)
   axterm doctor                    \uCE68\uBB35\uD558\uB294 \uC2E4\uD328\uB97C \uC9C4\uB2E8: \uC5D0\uC774\uC804\uD2B8 \uBC14\uC774\uB108\uB9AC, \uD6C5 \uC124\uC815, codex \uC2E0\uB8B0, \uBE0C\uB9AC\uC9C0
+  axterm quota                     \uAC01 \uC5D0\uC774\uC804\uD2B8\uC758 \uC0AC\uC6A9\uB7C9 \uD55C\uB3C4 \uC18C\uC9C4 \uC815\uB3C4 (\uC5D0\uC774\uC804\uD2B8 \uC790\uC2E0\uC758 \uAE30\uB85D\uC5D0\uC11C)
   axterm config list|get <\uACBD\uB85C>|set <\uACBD\uB85C> <\uAC12>|unset <\uACBD\uB85C>|path|import-env [\uD30C\uC77C]
 
 \uC5B8\uC5B4: AXTERM_LANG=en|ko \uB610\uB294 \`axterm config set locale ko\`
@@ -959,7 +1165,9 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.sessions.removed": "\uC138\uC158 {count}\uAC1C \uC0AD\uC81C\uB428",
     "cli.sessions.noneExited": "\uC0AD\uC81C\uD560 \uC885\uB8CC\uB41C \uC138\uC158\uC774 \uC5C6\uC2B5\uB2C8\uB2E4",
     "cli.session.removeFailed": "{id} \uC0AD\uC81C \uC2E4\uD328: {error}",
-    "cli.session.created": "\uC138\uC158 {id} \uC0DD\uC131\uB428 ({shell}, pid {pid})",
+    "cli.session.created": "\uC138\uC158 {id} \uC0DD\uC131\uB428 ({shell}, pid {pid}) \u2014 \uC7AC\uC811\uC18D: `axterm attach {id}` \uB610\uB294 `axterm attach --last`",
+    "cli.attach.picked": "{id} ({name}) \uC5D0 \uC811\uC18D\uD569\uB2C8\uB2E4 \u2014 \uC774 \uD3F4\uB354\uC5D0\uC11C \uAC00\uC7A5 \uCD5C\uADFC\uC5D0 \uB9CC\uB4E0 \uC0B4\uC544\uC788\uB294 \uC138\uC158\uC785\uB2C8\uB2E4",
+    "cli.attach.noRecent": "\uC774 \uD3F4\uB354\uC5D0 \uC7AC\uC811\uC18D\uD560 \uC0B4\uC544\uC788\uB294 \uC138\uC158\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 `axterm list --all` \uB85C \uC804\uCCB4\uB97C \uBCF4\uC138\uC694",
     "cli.session.killed": "\uC885\uB8CC\uB428",
     "cli.session.sent": "\uC804\uB2EC\uB428",
     "cli.session.sentKey": "{key} \uC804\uB2EC\uB428",
@@ -987,7 +1195,7 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.update.notBinary": "\uC774 axterm \uC740 \uC18C\uC2A4\uC5D0\uC11C \uC2E4\uD589 \uC911\uC774\uB77C \uAD50\uCCB4\uD560 \uC2E4\uD589 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. git pull \uC744 \uC0AC\uC6A9\uD558\uC138\uC694",
     "cli.flag.needsValue": "--{flag} \uC5D0\uB294 \uAC12\uC774 \uD544\uC694\uD569\uB2C8\uB2E4",
     "cli.key.unknown": "\uC54C \uC218 \uC5C6\uB294 \uD0A4: {name}",
-    "cli.usage.attach": "\uC0AC\uC6A9\uBC95: axterm attach <id>",
+    "cli.usage.attach": "\uC0AC\uC6A9\uBC95: axterm attach <id>   (\uB610\uB294 `axterm attach --last`)",
     "cli.usage.send": "\uC0AC\uC6A9\uBC95: axterm send [--raw] <id> <\uD14D\uC2A4\uD2B8...>",
     "cli.usage.screen": "\uC0AC\uC6A9\uBC95: axterm screen <id>",
     "cli.usage.esc": "\uC0AC\uC6A9\uBC95: axterm esc <id>",
@@ -1000,14 +1208,14 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "cli.usage.diff": "\uC0AC\uC6A9\uBC95: axterm diff <id> [--base REF]",
     "cli.usage.config": "\uC0AC\uC6A9\uBC95: axterm config list|get|set|unset|path|import-env",
     "cli.usage.configGet": "\uC0AC\uC6A9\uBC95: axterm config get <\uACBD\uB85C> [--reveal]",
-    "cli.usage.configSet": "\uC0AC\uC6A9\uBC95: axterm config set <\uACBD\uB85C> <\uAC12>",
+    "cli.usage.configSet": "\uC0AC\uC6A9\uBC95: axterm config set <\uACBD\uB85C> <\uAC12>   (- \uB85C \uC2DC\uC791\uD558\uB294 \uAC12\uC740 `--` \uB4A4\uC5D0)",
     "cli.usage.configUnset": "\uC0AC\uC6A9\uBC95: axterm config unset <\uACBD\uB85C>",
     "cli.usage.project": "\uC0AC\uC6A9\uBC95: axterm project add|list|rm",
     "cli.usage.projectRm": "\uC0AC\uC6A9\uBC95: axterm project rm <\uBCC4\uCE6D>",
     "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.telegram": "\uC0AC\uC6A9\uBC95: axterm telegram link|doctor|status",
+    "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",
     "cli.config.unset": "{path} \uD574\uC81C\uB428",
@@ -1030,9 +1238,16 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.help.general.wt": "/wt <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> \u2014 worktree \uC138\uC158",
     "tg.help.general.fanout": "/fanout <\uD504\uB85C\uC81D\uD2B8> <\uAC1C\uC218|\uBE0C\uB79C\uCE58\uB4E4> <\uD504\uB86C\uD504\uD2B8> \u2014 \uBCD1\uB82C \uC2E4\uD589",
     "tg.help.general.worktrees": "/worktrees <\uD504\uB85C\uC81D\uD2B8> \xB7 /rm <\uD504\uB85C\uC81D\uD2B8> <\uBE0C\uB79C\uCE58> [force]",
+    "cli.telegram.discoverHint": "\uD1A0\uD53D\uC744 \uCF20 \uADF8\uB8F9\uC744 \uB9CC\uB4E4\uACE0 \uBD07\uC744 \uCD08\uB300\uD55C \uB4A4 \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694. \uCD08\uB300\uB9CC \uD558\uBA74 \uCDA9\uBD84\uD569\uB2C8\uB2E4 \u2014 \uBA54\uC2DC\uC9C0\uB97C \uBCF4\uB0BC \uD544\uC694\uB294 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    "cli.telegram.discoverNone": "\uBD07\uC774 \uC544\uC9C1 \uC5B4\uB5A4 \uADF8\uB8F9\uB3C4 \uBCFC \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    "cli.telegram.discoverChats": "\uBD07\uC774 \uBCFC \uC218 \uC788\uB294 \uADF8\uB8F9 (\uC774 id\uB97C --group \uC5D0 \uC0AC\uC6A9):",
+    "cli.telegram.discoverUsers": "\uBD07\uC774 \uBCF8 \uC0AC\uC6A9\uC790 (\uC774 id\uB97C --user \uC5D0 \uC0AC\uC6A9):",
+    "cli.telegram.topicsOff": "\uD1A0\uD53D\uC774 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4 \u2014 axterm\uC5D0 \uD544\uC694\uD569\uB2C8\uB2E4. \uADF8\uB8F9 \uC124\uC815\uC5D0\uC11C \uD1A0\uD53D\uC744 \uCF1C\uC138\uC694",
+    "err.telegram.discoverWhileRunning": "\uD154\uB808\uADF8\uB7A8 \uCC44\uB110\uC774 \uC774\uBBF8 \uC2E4\uD589 \uC911\uC774\uACE0, \uD154\uB808\uADF8\uB7A8\uC740 \uBD07 \uD1A0\uD070\uB2F9 \uB9AC\uB354\uB97C \uD558\uB098\uB9CC \uD5C8\uC6A9\uD569\uB2C8\uB2E4 \u2014 `axterm config set channels.telegram.enabled false` \uB85C \uBA48\uCD98 \uB4A4 \uD0D0\uC0C9\uD558\uAC70\uB098, `axterm telegram status` \uC5D0\uC11C id\uB97C \uD655\uC778\uD558\uC138\uC694",
+    "err.telegram.noToken": "\uBD07 \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4 \u2014 `axterm setup` \uC744 \uC2E4\uD589\uD558\uAC70\uB098 --token \uC744 \uB118\uAE30\uC138\uC694",
     "tg.help.general.sessions": "/sessions \u2014 \uC138\uC158 \uBAA9\uB85D",
     "tg.help.topic.header": "\uC138\uC158 \uD1A0\uD53D \uC548\uC5D0\uC11C\uB294 \uC77C\uBC18 \uBA54\uC2DC\uC9C0\uAC00 \uD504\uB86C\uD504\uD2B8\uB85C \uC804\uB2EC\uB429\uB2C8\uB2E4.",
-    "tg.help.topic.commands": "/esc \uC911\uB2E8 \xB7 /screen \uD654\uBA74 \xB7 /diff \uBCC0\uACBD\uC694\uC57D \xB7 /resume \uB300\uD654 \uC774\uC5B4\uC11C \uC7AC\uC2DC\uC791 \xB7 /kill \uC885\uB8CC",
+    "tg.help.topic.commands": "/esc \uC911\uB2E8 \xB7 /screen \uD654\uBA74 \xB7 /diff \uBCC0\uACBD\uC694\uC57D \xB7 /quota \uC0AC\uC6A9\uB7C9 \xB7 /key\xB7/type \uC6D0\uC2DC \uC785\uB825 \xB7 /resume \uB300\uD654 \uC774\uC5B4\uC11C \uC7AC\uC2DC\uC791 \xB7 /kill \uC885\uB8CC",
     "tg.session.started": `\u25B6 \uC138\uC158 {id} \uC2DC\uC791
 {command}
 \uD83D\uDCC1 {cwd}`,
@@ -1056,6 +1271,15 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "tg.shell.only": "(\uC178)",
     "tg.agent.failed": "\uD83D\uDED1 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC774\uBC88 \uD134\uC744 \uB05D\uB0B4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: {error}",
     "tg.agent.retry": "\u23F3 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC694\uCCAD \uD55C\uB3C4\uC5D0 \uAC78\uB824 {wait} \uD6C4 \uC7AC\uC2DC\uB3C4\uD569\uB2C8\uB2E4: {error}",
+    "tg.raw.keysSent": "\u2328\uFE0F \uC804\uC1A1: {keys}",
+    "tg.raw.unknownKey": '\uC54C \uC218 \uC5C6\uB294 \uD0A4 "{name}" \u2014 \uC544\uBB34\uAC83\uB3C4 \uBCF4\uB0B4\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uAC00\uB2A5\uD55C \uD0A4: {keys}',
+    "tg.raw.typed": `\u2328\uFE0F \uC785\uB825\uD588\uC2B5\uB2C8\uB2E4 (\uC544\uC9C1 \uC81C\uCD9C \uC548 \uD568 \u2014 \uBCF4\uB0B4\uB824\uBA74 /key enter):
+<pre>{screen}</pre>`,
+    "tg.raw.needText": "\uC0AC\uC6A9\uBC95: /type <\uD14D\uC2A4\uD2B8> \u2014 Enter \uC5C6\uC774 \uADF8\uB300\uB85C \uC785\uB825\uB429\uB2C8\uB2E4. \uC774\uD6C4 /key enter.",
+    "tg.raw.tooLong": "\uC6D0\uC2DC \uC785\uB825\uC73C\uB85C\uB294 \uB108\uBB34 \uAE41\uB2C8\uB2E4 (\uCD5C\uB300 {limit}\uC790) \u2014 \uC77C\uBC18 \uBA54\uC2DC\uC9C0\uB85C \uBCF4\uB0B4\uC138\uC694",
+    "tg.agent.attempt": "\u26A0\uFE0F \uC2DC\uB3C4\uAC00 \uD55C \uBC88 \uC2E4\uD328\uD574 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC7AC\uC2DC\uB3C4\uD569\uB2C8\uB2E4: {error}",
+    "tg.agent.stalled": `\u23F8\uFE0F {wait} \uB3D9\uC548 \uC9C4\uC804\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uC5D0\uC774\uC804\uD2B8\uAC00 \uC774\uC720\uB97C \uB9D0\uD558\uC9C0 \uC54A\uC558\uC73C\uBBC0\uB85C, \uB9C8\uC9C0\uB9C9\uC73C\uB85C \uCD9C\uB825\uD55C \uB0B4\uC6A9\uC785\uB2C8\uB2E4:
+<pre>{screen}</pre>`,
     "tg.inbound.tooLarge": "\u26A0\uFE0F {limit} \uC81C\uD55C\uC744 \uB118\uB294 \uD30C\uC77C\uC785\uB2C8\uB2E4 \u2014 \uB0B4\uB824\uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
     "tg.inbound.empty": "\u26A0\uFE0F \uBE48 \uD30C\uC77C\uC774\uB77C \uC138\uC158\uC5D0 \uC804\uB2EC\uD560 \uB0B4\uC6A9\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uB0B4\uB824\uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
     "tg.inbound.noSession": "\u26A0\uFE0F \uD30C\uC77C\uC740 \uC138\uC158 \uD1A0\uD53D \uC548\uC5D0\uC11C \uBCF4\uB0B4\uC8FC\uC138\uC694 \u2014 \uC774 \uD1A0\uD53D\uC5D0 \uC5F0\uACB0\uB41C \uC138\uC158\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
@@ -1131,6 +1355,15 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "doctor.telegram.ok": "\uD154\uB808\uADF8\uB7A8: \uC5F0\uACB0\uB428",
     "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",
+    "quota.gaugeStale": "{agent}: {window} \uD55C\uB3C4\uC758 {percent}% \uC0AC\uC6A9, {resets} \uD6C4 \uCD08\uAE30\uD654 ({age} \uC804 \uAE30\uB85D)",
+    "quota.gaugeElapsed": "{agent}: {window} \uD55C\uB3C4\uC758 {percent}% \uC0AC\uC6A9, \uD574\uB2F9 \uCC3D\uC740 \uC774\uBBF8 \uCD08\uAE30\uD654\uB428",
+    "quota.reached": "{agent}: \uD55C\uB3C4\uC5D0 \uB3C4\uB2EC\uD568 \u2014 {window} \uD55C\uB3C4\uC758 {percent}%, {resets} \uD6C4 \uCD08\uAE30\uD654",
+    "quota.event": "{agent}: {age} \uC804 \uD55C\uB3C4\uC5D0 \uAC78\uB838\uC2B5\uB2C8\uB2E4 \u2014 {text}",
+    "quota.eventNone": "{agent}: \uD55C\uB3C4 \uAE30\uB85D \uC5C6\uC74C (\uC0AC\uC6A9\uB960\uC744 \uB0A8\uAE30\uC9C0 \uC54A\uB294 \uC5D0\uC774\uC804\uD2B8)",
+    "quota.noData": "{agent}: \uC544\uC9C1 \uAE30\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBA3C\uC800 \uD55C \uD134 \uC2E4\uD589\uD558\uC138\uC694",
+    "quota.unsupported": "{agent}: \uC0AC\uC6A9\uB7C9 \uD55C\uB3C4\uB97C \uC804\uD600 \uBCF4\uACE0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+    "cli.quota.none": "\uC774 \uCEF4\uD4E8\uD130\uC758 \uC5B4\uB5A4 \uC5D0\uC774\uC804\uD2B8\uB3C4 \uC0AC\uC6A9\uB7C9 \uD55C\uB3C4\uB97C \uBCF4\uACE0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
     "fanout.needCountOrBranches": "\uBE0C\uB79C\uCE58 \uC218\uB098 \uBE0C\uB79C\uCE58 \uBAA9\uB85D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4",
     "fanout.needPrompt": "\uD504\uB86C\uD504\uD2B8\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4",
     "fanout.outOfRange": "1..{max} \uBC94\uC704\uC5EC\uC57C \uD569\uB2C8\uB2E4",
@@ -1154,11 +1387,12 @@ usage: /fanout <project> <count|branches> <prompt>`,
     "health.telegram.noUsers": "Telegram\uC774 \uCF1C\uC838 \uC788\uC9C0\uB9CC \uC870\uC791\uC744 \uD5C8\uC6A9\uD55C \uC0AC\uC6A9\uC790\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
     "wizard.prompt.locale": "\uC5B8\uC5B4",
     "wizard.prompt.machine": "\uC774 \uBA38\uC2E0\uC758 \uC774\uB984 (\uCC44\uB110\uC5D0\uC11C \uC9C0\uC815\uD560 \uB54C \uC500)",
-    "wizard.prompt.agent": "\uAE30\uBCF8 \uC5D0\uC774\uC804\uD2B8 \uBA85\uB839",
+    "wizard.prompt.agent": "\uAE30\uBCF8 \uC5D0\uC774\uC804\uD2B8 (\uCD94\uAC00 \uD50C\uB798\uADF8\uB294 defaults.agentArgs.<\uC5D0\uC774\uC804\uD2B8> \uC5D0)",
     "wizard.prompt.telegram": "\uC9C0\uAE08 Telegram \uC81C\uC5B4\uB97C \uC124\uC815\uD560\uAE4C\uC694?",
+    "wizard.prompt.agentApproval": "\uC774 \uC5D0\uC774\uC804\uD2B8\uAC00 \uC2B9\uC778 \uC5C6\uC774 \uC791\uC5C5\uD558\uB3C4\uB85D \uD560\uAE4C\uC694? \uBAA8\uB4E0 \uAD8C\uD55C \uD655\uC778\uC744 \uAC74\uB108\uB701\uB2C8\uB2E4 \u2014 \uD3F0\uC5D0\uC11C \uD3B8\uD558\uC9C0\uB9CC, \uC138\uC158 \uD3F4\uB354 \uC548\uC5D0\uC11C \uBB34\uC5C7\uC774\uB4E0 \uC218\uC815\xB7\uC2E4\uD589\uD560 \uC218 \uC788\uAC8C \uB429\uB2C8\uB2E4. `axterm config set defaults.autoApprove false` \uB85C \uB418\uB3CC\uB9AC\uAC70\uB098, \uD55C \uC138\uC158\uB9CC\uC774\uB77C\uBA74 `axterm run --no-auto-approve` \uB97C \uC4F0\uC138\uC694.",
     "wizard.prompt.telegramToken": "@BotFather \uC5D0\uC11C \uBC1B\uC740 \uBD07 \uD1A0\uD070",
-    "wizard.prompt.telegramGroup": "\uADF8\uB8F9 id (\uC74C\uC218, \uBCF4\uD1B5 -100 \uC73C\uB85C \uC2DC\uC791)",
-    "wizard.prompt.telegramUsers": "axterm \uC870\uC791\uC744 \uD5C8\uC6A9\uD560 Telegram user id (\uC27C\uD45C\uB85C \uAD6C\uBD84)",
+    "wizard.prompt.telegramGroup": "\uADF8\uB8F9 id (\uC74C\uC218, \uBCF4\uD1B5 -100 \uC73C\uB85C \uC2DC\uC791. `axterm telegram discover` \uB85C \uD655\uC778 \uAC00\uB2A5)",
+    "wizard.prompt.telegramUsers": "axterm \uC870\uC791\uC744 \uD5C8\uC6A9\uD560 Telegram user id (\uC27C\uD45C\uB85C \uAD6C\uBD84. `axterm telegram discover` \uB85C \uD655\uC778 \uAC00\uB2A5)",
     "wizard.prompt.review": "\uC774 \uC124\uC815\uC744 \uC800\uC7A5\uD560\uAE4C\uC694?",
     "wizard.error.locale": "\uC81C\uC2DC\uB41C \uC5B8\uC5B4 \uC911\uC5D0\uC11C \uACE0\uB974\uC138\uC694",
     "wizard.error.machine": "\uC601\uBB38\xB7\uC22B\uC790\uC640 . - _ \uB9CC \uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4",
@@ -1195,6 +1429,8 @@ function defaultFor(step, config, hostname) {
       return config.machine?.name ?? hostname;
     case "agent":
       return config.defaults?.agent ?? "omp";
+    case "agentApproval":
+      return "no";
     case "telegram":
       return telegram?.enabled === true ? "yes" : "no";
     case "telegramGroup":
@@ -1228,6 +1464,7 @@ function collect(answers) {
     ["machine.name", answers["machine"] ?? ""],
     ["defaults.agent", answers["agent"] ?? "omp"]
   ];
+  settings.push(["defaults.autoApprove", YES.has(answers["agentApproval"] ?? "") ? "true" : "false"]);
   const secrets = [];
   const wantsTelegram = YES.has(answers["telegram"] ?? "");
   settings.push(["channels.telegram.enabled", wantsTelegram ? "true" : "false"]);
@@ -1265,6 +1502,7 @@ var YES, NO, numericList = (value) => {
   return parts.length > 0 && parts.every((p) => /^-?\d+$/.test(p)) ? undefined : "wizard.error.numberList";
 }, STEPS, wizardConfig;
 var init_setup_wizard = __esm(() => {
+  init_agent_launch();
   init_i18n();
   YES = new Set(["y", "yes", "true", "1"]);
   NO = new Set(["n", "no", "false", "0"]);
@@ -1283,9 +1521,17 @@ var init_setup_wizard = __esm(() => {
       next: () => "agent"
     },
     agent: {
-      kind: "text",
+      kind: "select",
       promptKey: "wizard.prompt.agent",
-      validate: (v) => v.trim().length > 0 ? undefined : "wizard.error.agent",
+      choices: [...supportedAgents()],
+      validate: (v) => supportedAgents().includes(v.trim()) ? undefined : "wizard.error.agent",
+      next: () => "agentApproval"
+    },
+    agentApproval: {
+      kind: "select",
+      promptKey: "wizard.prompt.agentApproval",
+      choices: ["yes", "no"],
+      validate: (v) => YES.has(v) || NO.has(v) ? undefined : "wizard.error.yesNo",
       next: () => "telegram"
     },
     telegram: {
@@ -1355,7 +1601,7 @@ function oscTitle(title) {
   const safe = title.replace(/[\x00-\x1f\x7f]/g, "").slice(0, MAX_TITLE_LENGTH);
   return `\x1B]0;${safe}\x07`;
 }
-var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, MAX_TITLE_LENGTH = 200;
+var SPINNER_FRAMES, MENU_APPROVE = "\r", PROFILES, REGISTERED_AGENTS, MAX_TITLE_LENGTH = 200;
 var init_agent_registry = __esm(() => {
   SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   PROFILES = {
@@ -1364,6 +1610,8 @@ var init_agent_registry = __esm(() => {
       displayName: "OMP",
       title: { workingLabel: "OMP", permissionLabel: "OMP - action required", idleLabel: "OMP ready" },
       hostHookSource: "omp",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
+      quota: "gauge",
       resume: { argv: ["--resume", "{ref}"], ref: "sessionFile" }
     },
     pi: {
@@ -1383,6 +1631,8 @@ var init_agent_registry = __esm(() => {
         synthesizeWorking: false
       },
       hostHookSource: "codex",
+      quota: "gauge",
+      approvalBypassArgs: ["--dangerously-bypass-approvals-and-sandbox"],
       structuredApprovals: true,
       resume: { argv: ["resume", "{ref}"], ref: "sessionId", form: "subcommand" }
     },
@@ -1427,6 +1677,8 @@ var init_agent_registry = __esm(() => {
         synthesizeTerminal: false
       },
       hostHookSource: "claude",
+      quota: "event",
+      approvalBypassArgs: ["--permission-mode", "bypassPermissions"],
       resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
     },
     gemini: {
@@ -1440,11 +1692,13 @@ var init_agent_registry = __esm(() => {
         synthesizeTerminal: false
       },
       hostHookSource: "gemini",
+      approvalBypassArgs: ["--approval-mode", "yolo"],
       hookAck: "{}",
       approvalKeys: { allow: MENU_APPROVE, deny: "\x1B" },
       resume: { argv: ["--resume", "{ref}"], ref: "sessionId" }
     }
   };
+  REGISTERED_AGENTS = Object.keys(PROFILES);
 });
 
 // packages/core/src/agent-resume.ts
@@ -1502,6 +1756,13 @@ function hookLaunch(input) {
 function isHookInvocation(args) {
   return args[0] === HOOK_ARGV_FLAG && typeof args[1] === "string" && args[1] !== "";
 }
+function mcpLaunch(input) {
+  const base = daemonLaunch(input);
+  return { command: base.command, args: [...base.args.slice(0, -1), MCP_ARGV_FLAG] };
+}
+function isMcpInvocation(args) {
+  return args[0] === MCP_ARGV_FLAG;
+}
 function hookPostTarget(env, agent) {
   const port = Number(env["AXTERM_HOOK_PORT"]);
   const token = env["AXTERM_HOOK_TOKEN"];
@@ -1524,7 +1785,7 @@ function hookPostTarget(env, agent) {
 function isDaemonInvocation(args) {
   return args[0] === DAEMON_ARGV_FLAG;
 }
-var DAEMON_ARGV_FLAG = "__daemon", HOOK_ARGV_FLAG = "__hook", RUNTIME_NAMES;
+var DAEMON_ARGV_FLAG = "__daemon", HOOK_ARGV_FLAG = "__hook", MCP_ARGV_FLAG = "__mcp", RUNTIME_NAMES;
 var init_self_spawn = __esm(() => {
   RUNTIME_NAMES = new Set(["bun", "bun.exe", "bun-debug", "bun-debug.exe", "node", "node.exe"]);
 });
@@ -1603,6 +1864,15 @@ function updateNeeded(current, latest) {
     return false;
   return Bun.semver.order(latest, current) > 0;
 }
+function classifyRuntimeLane(main) {
+  const normalised = main.replace(/\\/g, "/");
+  if (normalised.split("/").includes("node_modules")) {
+    return normalised.includes("/.bun/") ? "bun" : "npm";
+  }
+  if (normalised.endsWith(".ts") || normalised.endsWith(".js"))
+    return "checkout";
+  return "binary";
+}
 function planBinarySwap(input) {
   const steps = [];
   if (input.platform !== "win32")
@@ -1612,16 +1882,16 @@ function planBinarySwap(input) {
   return steps;
 }
 function planSessionRestore(sessions) {
-  const running = sessions.filter((s) => s.state === "running");
+  const live = sessions.filter((s) => s.state !== "exited");
   const resumable = (s) => agentProfile(agentIdFromCommand(s.agentCommand)).resume !== undefined;
   return {
-    resume: running.filter(resumable).map((s) => s.id),
-    cannotResume: running.filter((s) => !resumable(s)),
-    needsConfirmation: running.length > 0
+    resume: live.filter(resumable).map((s) => s.id),
+    cannotResume: live.filter((s) => !resumable(s)),
+    needsConfirmation: live.length > 0
   };
 }
 function planUpdateRestart(input) {
-  const live = input.sessions.filter((s) => s.state === "running").length;
+  const live = input.sessions.filter((s) => s.state !== "exited").length;
   if (!input.restart && live > 0) {
     return { stopDaemon: false, resume: [], lost: [], stale: live, needsConfirmation: false };
   }
@@ -1769,6 +2039,44 @@ class EchoGuard {
     this.pending.delete(sessionId);
   }
 }
+
+// packages/core/src/ask.ts
+function answerText(answer) {
+  if (!answer)
+    return "(no answer)";
+  const parts = [...answer.selected];
+  if (answer.customInput !== undefined && answer.customInput.length > 0)
+    parts.push(answer.customInput);
+  return parts.join(", ") || "(no answer)";
+}
+function detailsFor(question, answer) {
+  return {
+    ...question.id !== undefined ? { id: question.id } : {},
+    question: question.question,
+    options: question.options.map((o) => o.label),
+    multi: question.multi,
+    selectedOptions: answer?.selected ?? [],
+    ...answer?.customInput !== undefined ? { customInput: answer.customInput } : {}
+  };
+}
+function formatAskResult(questions, answers) {
+  const byIndex = new Map(answers.map((a) => [a.questionIndex, a]));
+  if (questions.length === 1) {
+    const question = questions[0];
+    return {
+      text: answerText(byIndex.get(0)),
+      details: detailsFor(question, byIndex.get(0))
+    };
+  }
+  const lines = questions.map((q, i) => `${q.id ?? String(i)}: ${answerText(byIndex.get(i))}`);
+  return {
+    text: `User answers:
+${lines.join(`
+`)}`,
+    details: { results: questions.map((q, i) => detailsFor(q, byIndex.get(i))) }
+  };
+}
+
 // packages/core/src/choice.ts
 function buildApprovalQuestion(toolName) {
   return {
@@ -1999,8 +2307,7 @@ function mapClaudeHook(input) {
           ...input.tool_input !== undefined ? { tool_input: input.tool_input } : {}
         }
       ];
-    case "Stop":
-    case "StopFailure": {
+    case "Stop": {
       const out = [];
       const text = input.last_assistant_message;
       if (typeof text === "string" && text.trim() !== "") {
@@ -2009,6 +2316,19 @@ function mapClaudeHook(input) {
       out.push({ event: "agent_end" });
       return out;
     }
+    case "StopFailure": {
+      const parts = [input.error, input.error_details, input.last_assistant_message].filter((part) => typeof part === "string" && part.trim() !== "").map((part) => part.trim());
+      return [
+        { event: "agent_error", error_kind: "failed", text: parts.join(" \u2014 ") },
+        { event: "agent_end" }
+      ];
+    }
+    case "MessageDisplay": {
+      const delta = input.delta;
+      if (typeof delta !== "string" || delta === "")
+        return [];
+      return [{ event: "activity", activity: "reply", text: delta }];
+    }
     case "SessionEnd":
       return [
         { event: "session_shutdown", ...input.session_id !== undefined ? { session_id: input.session_id } : {} }
@@ -2041,16 +2361,26 @@ function buildClaudeSettings(input) {
 var MAX_RESULT_TEXT = 2000, HOOK_TIMEOUT_SECONDS = 5, TOOL_EVENTS, PLAIN_EVENTS;
 var init_claude_hooks = __esm(() => {
   TOOL_EVENTS = ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest"];
-  PLAIN_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure", "SessionEnd"];
+  PLAIN_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "Stop",
+    "StopFailure",
+    "MessageDisplay",
+    "SessionEnd"
+  ];
 });
 
-// packages/core/src/gemini-onboarding.ts
-function detectGeminiOnboarding(screen) {
+// packages/core/src/onboarding.ts
+function detectOnboarding(agent, screen) {
+  const dialogs = DIALOGS[agent];
+  if (dialogs === undefined)
+    return;
   const lines = screen.split(`
 `).map((line) => line.replace(/^\s*\u2502/, "").replace(/\u2502\s*$/, "").trim());
   for (let i = lines.length - 1;i >= 0; i--) {
     const line = lines[i];
-    const dialog = DIALOGS.find((d) => line === d.question);
+    const dialog = dialogs.find((d) => line.startsWith(d.question));
     if (!dialog)
       continue;
     const options = [];
@@ -2066,12 +2396,19 @@ function detectGeminiOnboarding(screen) {
   return;
 }
 var DIALOGS, OPTION_ROW, OPTION_WINDOW_LINES = 8;
-var init_gemini_onboarding = __esm(() => {
-  DIALOGS = [
-    { kind: "folderTrust", question: "Do you trust the files in this folder?" },
-    { kind: "authMethod", question: "How would you like to authenticate for this project?" }
-  ];
-  OPTION_ROW = /^[\u25CF\u25CB]?\s*(\d)\.\s+(.+)$/;
+var init_onboarding = __esm(() => {
+  DIALOGS = {
+    gemini: [
+      { kind: "folderTrust", question: "Do you trust the files in this folder?" },
+      { kind: "authMethod", question: "How would you like to authenticate for this project?" }
+    ],
+    claude: [
+      { kind: "apiKey", question: "Do you want to use this API key?" },
+      { kind: "loginMethod", question: "Select login method:" }
+    ],
+    codex: [{ kind: "folderTrust", question: "Do you trust the contents of this directory?" }]
+  };
+  OPTION_ROW = /^[\u25CF\u25CB\u276F>\u203A]?\s*(\d)\.\s+(.+)$/;
 });
 
 // packages/core/src/doctor.ts
@@ -2206,87 +2543,587 @@ var init_doctor = __esm(() => {
   GEMINI_FORBIDDEN_EVENTS = ["AfterModel", "BeforeModel"];
 });
 
-// packages/core/src/version.ts
-function setProductVersion(version) {
-  product = version;
+// packages/core/src/stall.ts
+function shouldReportStall(input) {
+  if (input.reported)
+    return false;
+  if (input.agentState !== "working")
+    return false;
+  if (input.quietForMs <= input.thresholdMs)
+    return false;
+  if (input.storeQuietForMs !== undefined && input.storeQuietForMs <= input.thresholdMs)
+    return false;
+  return true;
 }
-function productVersion() {
-  return product;
+function quoteScreenTail(screen, maxLines) {
+  const kept = [];
+  const lines = screen.split(`
+`);
+  for (let i = lines.length - 1;i >= 0 && kept.length < maxLines; i--) {
+    const line = lines[i];
+    if (CHROME_ONLY.test(line))
+      continue;
+    const text = line.replace(EDGE_CHROME, "");
+    if (text === "")
+      continue;
+    kept.push(text);
+  }
+  return kept.reverse();
 }
-var product = "";
+var CHROME_ONLY, EDGE_CHROME;
+var init_stall = __esm(() => {
+  CHROME_ONLY = /^[\s\u2502\u2503|\u256D\u256E\u2570\u256F\u251C\u2524\u252C\u2534\u253C\u2500\u2501\u2550\u254C\u254D\u2504\u2505.\u00B7*]*$/u;
+  EDGE_CHROME = /^[\s\u2502\u2503|]+|[\s\u2502\u2503|]+$/gu;
+});
 
-// packages/core/src/codex-hooks.ts
-import { createHash } from "crypto";
-function quoteToken(token) {
-  if (token !== "" && !/[ \t"]/.test(token))
-    return token;
-  return `"${token.replaceAll('"', "\\\"")}"`;
-}
-function buildCodexHooks(input) {
-  const command = [input.command, ...input.args].map(quoteToken).join(" ");
-  const group = (timeout) => [
-    { hooks: [{ type: "command", command, timeout, async: false }] }
-  ];
-  const hooks = {};
-  for (const event of OBSERVATION_EVENTS)
-    hooks[event] = group(input.timeoutSeconds ?? OBSERVATION_TIMEOUT_SECONDS);
-  hooks["PermissionRequest"] = group(CODEX_PERMISSION_TIMEOUT_SECONDS);
-  hooks["SessionEnd"] = group(SESSION_END_TIMEOUT_SECONDS);
-  return { hooks };
-}
-function normalizedTimeout(event, timeout) {
-  if (event === "SessionEnd")
-    return Math.min(3, Math.max(1, timeout));
-  return Math.max(1, timeout);
+// packages/core/src/codex-stream.ts
+class CodexStreamMapper {
+  finalAnswerItems = new Set;
+  handle(method, params) {
+    switch (method) {
+      case "item/started": {
+        const item = params["item"];
+        if (!isRecord(item) || item["type"] !== "agentMessage")
+          return [];
+        if (item["phase"] === "final_answer" && typeof item["id"] === "string") {
+          this.finalAnswerItems.add(item["id"]);
+        }
+        return [];
+      }
+      case "item/reasoning/summaryTextDelta": {
+        const delta = params["delta"];
+        if (typeof delta !== "string" || delta === "")
+          return [];
+        return [{ event: "activity", activity: "thinking", text: delta }];
+      }
+      case "item/agentMessage/delta": {
+        const delta = params["delta"];
+        const itemId = params["itemId"];
+        if (typeof delta !== "string" || delta === "" || typeof itemId !== "string")
+          return [];
+        if (!this.finalAnswerItems.has(itemId))
+          return [];
+        return [{ event: "activity", activity: "reply", text: delta }];
+      }
+      case "error": {
+        const willRetry = params["willRetry"] === true;
+        const raw = params["error"];
+        const text = typeof raw === "string" ? raw : isRecord(raw) && typeof raw["message"] === "string" ? raw["message"] : JSON.stringify(raw ?? {});
+        return [{ event: "agent_error", error_kind: willRetry ? "retry" : "failed", text }];
+      }
+      case "thread/status/changed": {
+        const status = params["status"];
+        if (isRecord(status) && status["type"] === "idle")
+          this.finalAnswerItems.clear();
+        return [];
+      }
+      default:
+        return [];
+    }
+  }
 }
-function canonicalJson(value) {
-  if (Array.isArray(value))
-    return `[${value.map(canonicalJson).join(",")}]`;
-  if (typeof value === "object" && value !== null) {
-    const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
-    return `{${entries.join(",")}}`;
+var init_codex_stream = () => {};
+
+// packages/core/src/keys.ts
+function keySequence(name) {
+  return SEQUENCES[name];
+}
+function parseKeyNames(input) {
+  const names = input.trim().split(/\s+/).filter((name) => name !== "");
+  if (names.length === 0)
+    return { unknown: "" };
+  const keys = [];
+  for (const name of names) {
+    const sequence = keySequence(name);
+    if (sequence === undefined)
+      return { unknown: name };
+    keys.push(sequence);
+  }
+  return { keys };
+}
+var SEQUENCES, KEY_NAMES;
+var init_keys = __esm(() => {
+  SEQUENCES = {
+    approve: "\r",
+    deny: "\x1B[B\r",
+    enter: "\r",
+    esc: "\x1B",
+    up: "\x1B[A",
+    down: "\x1B[B",
+    left: "\x1B[D",
+    right: "\x1B[C",
+    tab: "\t",
+    space: " ",
+    "ctrl+c": "\x03",
+    "ctrl+d": "\x04",
+    backspace: "\x7F",
+    "shift+tab": "\x1B[Z"
+  };
+  KEY_NAMES = Object.keys(SEQUENCES).sort();
+});
+
+// packages/core/src/duration.ts
+function humanDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0)
+    return "0s";
+  const seconds = Math.max(1, Math.round(ms / 1000));
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    const rest = minutes % 60;
+    return rest === 0 ? `${hours}h` : `${hours}h ${rest}m`;
   }
-  return JSON.stringify(value);
+  const days = Math.floor(hours / 24);
+  const restHours = hours % 24;
+  return restHours === 0 ? `${days}d` : `${days}d ${restHours}h`;
 }
-function codexHookTrust(hooksJsonPath, file) {
-  const entries = [];
-  for (const [event, groups] of Object.entries(file.hooks)) {
-    const label = EVENT_KEY_LABELS[event];
-    if (label === undefined)
+
+// packages/core/src/quota.ts
+function quotaReport(facts, nowMs) {
+  const out = [];
+  for (const fact of facts) {
+    if (fact.kind === "none") {
+      out.push({ id: `quota.${fact.agent}`, status: "info", key: "quota.unsupported", params: { agent: fact.agent } });
       continue;
-    groups.forEach((group, groupIndex) => {
-      group.hooks.forEach((hook, hookIndex) => {
-        const identity = {
-          event_name: label,
-          ...group.matcher !== undefined ? { matcher: group.matcher } : {},
-          hooks: [
-            {
-              type: "command",
-              command: hook.command,
-              timeout: normalizedTimeout(event, hook.timeout),
-              async: hook.async
-            }
-          ]
-        };
-        const hash = `sha256:${createHash("sha256").update(canonicalJson(identity)).digest("hex")}`;
-        entries.push({ key: `${hooksJsonPath}:${label}:${groupIndex}:${hookIndex}`, hash });
+    }
+    if (fact.kind === "event") {
+      if (!fact.event) {
+        out.push({ id: `quota.${fact.agent}`, status: "ok", key: "quota.eventNone", params: { agent: fact.agent } });
+        continue;
+      }
+      out.push({
+        id: `quota.${fact.agent}`,
+        status: "warn",
+        key: "quota.event",
+        params: {
+          agent: fact.agent,
+          age: humanDuration(Math.max(0, nowMs - fact.event.at)),
+          text: fact.event.text
+        }
       });
+      continue;
+    }
+    const reading = fact.reading;
+    if (!reading || reading.windows.length === 0) {
+      out.push({ id: `quota.${fact.agent}`, status: "info", key: "quota.noData", params: { agent: fact.agent } });
+      continue;
+    }
+    const age = nowMs - reading.recordedAt;
+    reading.windows.forEach((window2, index) => {
+      const params = {
+        agent: fact.agent,
+        percent: window2.usedPercent,
+        window: window2.label ?? (window2.windowMinutes === undefined ? "?" : humanDuration(window2.windowMinutes * 60000)),
+        resets: humanDuration(Math.max(0, window2.resetsAt - nowMs)),
+        plan: reading.planType ?? "",
+        age: humanDuration(Math.max(0, age))
+      };
+      const id = reading.windows.length === 1 ? `quota.${fact.agent}` : `quota.${fact.agent}.${index}`;
+      if (reading.limitReached) {
+        out.push({ id, status: "warn", key: "quota.reached", params });
+        return;
+      }
+      if (window2.resetsAt <= nowMs) {
+        out.push({ id, status: "info", key: "quota.gaugeElapsed", params });
+        return;
+      }
+      out.push({ id, status: "ok", key: age > STALE_AFTER_MS ? "quota.gaugeStale" : "quota.gauge", params });
     });
   }
-  return entries;
-}
-function codexTrustStateToml(entries) {
-  return entries.map((e) => {
-    const key = e.key.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
-    return `[hooks.state."${key}"]
-trusted_hash = "${e.hash}"
-`;
-  }).join(`
-`);
+  return out;
 }
-function codexPermissionDecision(question, answers, denyMessage) {
-  const picked = answers?.find((a) => a.questionIndex === 0)?.selected[0];
-  if (picked === undefined)
+var STALE_AFTER_MS = 3600000;
+var init_quota = () => {};
+
+// packages/core/src/gemini-telemetry.ts
+function splitTelemetryRecords(buffer) {
+  if (buffer === "")
+    return { complete: [], remainder: "" };
+  const chunks = buffer.split(/\n(?=\{)/);
+  const last = chunks.pop() ?? "";
+  const complete = chunks.filter((chunk) => chunk.trim() !== "");
+  if (/\n\s*$/.test(last) || tryParse(last) !== undefined) {
+    if (last.trim() !== "")
+      complete.push(last);
+    return { complete, remainder: "" };
+  }
+  return { complete, remainder: last };
+}
+function tryParse(text) {
+  if (text.trim() === "")
+    return;
+  try {
+    const value = JSON.parse(text);
+    return isRecord(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function attributesOf(record) {
+  const attributes = record["attributes"];
+  if (Array.isArray(attributes)) {
+    const out = {};
+    for (const entry of attributes) {
+      if (Array.isArray(entry) && typeof entry[0] === "string")
+        out[entry[0]] = entry[1];
+    }
+    return out;
+  }
+  return isRecord(attributes) ? attributes : {};
+}
+function parseGeminiTelemetry(records) {
+  const failures = [];
+  for (const raw of records) {
+    const record = tryParse(raw);
+    if (record === undefined)
+      continue;
+    const attributes = attributesOf(record);
+    if (attributes["event.name"] !== "gemini_cli.api_error")
+      continue;
+    const type = typeof attributes["error.type"] === "string" ? attributes["error.type"] : "";
+    const message = typeof attributes["error.message"] === "string" ? attributes["error.message"] : "";
+    const timestamp = attributes["event.timestamp"];
+    const at = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    const status = attributes["status_code"];
+    failures.push({
+      ...Number.isFinite(at) ? { at } : {},
+      ...typeof status === "number" ? { status } : {},
+      text: [type, message].filter((part) => part !== "").join(": ")
+    });
+  }
+  return failures;
+}
+var init_gemini_telemetry = () => {};
+
+// packages/core/src/mcp-ask.ts
+function fieldName(index) {
+  return `q${index}`;
+}
+function elicitationSchema(questions) {
+  const properties = {};
+  const required = [];
+  questions.forEach((question, index) => {
+    const labels = question.options.map((option) => option.label).filter((label) => label !== "");
+    properties[fieldName(index)] = {
+      type: "string",
+      title: question.question,
+      ...labels.length > 0 ? { enum: labels } : {}
+    };
+    required.push(fieldName(index));
+  });
+  return { type: "object", properties, required };
+}
+function answersFromElicitation(questions, result) {
+  if (!result || result.action !== "accept" || !isRecord(result.content))
+    return;
+  const answers = [];
+  questions.forEach((question, index) => {
+    const value = result.content?.[fieldName(index)];
+    if (typeof value !== "string" || value === "")
+      return;
+    const matched = question.options.some((option) => option.label === value);
+    answers.push(matched ? { questionIndex: index, selected: [value] } : { questionIndex: index, selected: [], customInput: value });
+  });
+  return answers.length > 0 ? answers : undefined;
+}
+var init_mcp_ask = () => {};
+
+// packages/core/src/store-locate.ts
+function claudeHash(text) {
+  let hash = 0;
+  for (let i = 0;i < text.length; i++)
+    hash = (hash << 5) - hash + text.charCodeAt(i) | 0;
+  return hash;
+}
+function claudeProjectKey(cwd) {
+  const key = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+  if (key.length <= CLAUDE_KEY_LIMIT)
+    return key;
+  return `${key.slice(0, CLAUDE_KEY_LIMIT)}-${Math.abs(claudeHash(cwd)).toString(36)}`;
+}
+function claudeTranscriptRelPath(cwd, sessionId) {
+  return `projects/${claudeProjectKey(cwd)}/${sessionId}.jsonl`;
+}
+function uuidV7TimeMs(id) {
+  const hex = id.replace(/-/g, "");
+  if (!/^[0-9a-f]{32}$/i.test(hex))
+    return;
+  const ms = Number.parseInt(hex.slice(0, 12), 16);
+  return Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+function shard(date) {
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}/${month}/${day}`;
+}
+function codexRolloutShards(sessionId) {
+  const ms = uuidV7TimeMs(sessionId);
+  if (ms === undefined)
+    return [];
+  return [shard(new Date(ms)), shard(new Date(ms - 86400000)), shard(new Date(ms + 86400000))];
+}
+var CLAUDE_KEY_LIMIT = 200;
+
+// packages/core/src/store-quota.ts
+function parseLine(line) {
+  if (line.trim() === "")
+    return;
+  try {
+    const value = JSON.parse(line);
+    return isRecord(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function numberOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function codexWindow(value) {
+  if (!isRecord(value))
+    return;
+  const usedPercent = numberOf(value["used_percent"]);
+  const resetsAtSeconds = numberOf(value["resets_at"]);
+  if (usedPercent === undefined || resetsAtSeconds === undefined)
+    return;
+  const windowMinutes = numberOf(value["window_minutes"]);
+  return {
+    usedPercent,
+    resetsAt: resetsAtSeconds * 1000,
+    ...windowMinutes === undefined ? {} : { windowMinutes }
+  };
+}
+function parseCodexQuota(lines) {
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const record = parseLine(lines[i]);
+    const payload = record?.["payload"];
+    if (!isRecord(payload) || payload["type"] !== "token_count")
+      continue;
+    const limits = payload["rate_limits"];
+    if (!isRecord(limits))
+      continue;
+    const windows = [];
+    for (const key of ["primary", "secondary"]) {
+      const window2 = codexWindow(limits[key]);
+      if (window2)
+        windows.push(window2);
+    }
+    if (windows.length === 0)
+      continue;
+    const recordedAt = Date.parse(String(record?.["timestamp"] ?? ""));
+    const planType = limits["plan_type"];
+    return {
+      recordedAt: Number.isFinite(recordedAt) ? recordedAt : 0,
+      windows,
+      limitReached: limits["rate_limit_reached_type"] != null || limits["spend_control_reached"] === true,
+      ...typeof planType === "string" ? { planType } : {}
+    };
+  }
+  return;
+}
+function parseOmpQuota(rows) {
+  const windows = [];
+  let recordedAt = 0;
+  let limitReached = false;
+  for (const row of rows) {
+    if (row.used_fraction === null || row.resets_at === null)
+      continue;
+    windows.push({
+      usedPercent: Math.round(row.used_fraction * 100),
+      label: row.label,
+      resetsAt: row.resets_at
+    });
+    recordedAt = Math.max(recordedAt, row.recorded_at);
+    if (row.status !== null && row.status !== "ok")
+      limitReached = true;
+  }
+  return windows.length === 0 ? undefined : { recordedAt, windows, limitReached };
+}
+function parseClaudeLimitEvent(lines) {
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const record = parseLine(lines[i]);
+    if (!record || record["error"] !== "rate_limit")
+      continue;
+    const at = Date.parse(String(record["timestamp"] ?? ""));
+    const message = record["message"];
+    let text = "";
+    if (isRecord(message) && Array.isArray(message["content"])) {
+      for (const block of message["content"]) {
+        if (isRecord(block) && typeof block["text"] === "string")
+          text += block["text"];
+      }
+    }
+    if (text === "")
+      continue;
+    return { at: Number.isFinite(at) ? at : 0, text };
+  }
+  return;
+}
+var init_store_quota = () => {};
+
+// packages/core/src/version.ts
+function setProductVersion(version) {
+  product = version;
+}
+function productVersion() {
+  return product;
+}
+var product = "";
+
+// packages/core/src/telegram-discovery.ts
+function readChat(value) {
+  if (!isRecord(value))
+    return;
+  const id = value["id"];
+  const type = value["type"];
+  if (typeof id !== "number" || typeof type !== "string")
+    return;
+  const title = value["title"];
+  const isForum = value["is_forum"];
+  return {
+    id,
+    type,
+    ...typeof title === "string" ? { title } : {},
+    ...isForum === true ? { isForum: true } : {}
+  };
+}
+function readUser(value) {
+  if (!isRecord(value))
+    return;
+  const id = value["id"];
+  if (typeof id !== "number")
+    return;
+  if (value["is_bot"] === true)
+    return;
+  const username = value["username"];
+  const name = value["first_name"];
+  return {
+    id,
+    ...typeof username === "string" ? { username } : {},
+    ...typeof name === "string" ? { name } : {}
+  };
+}
+function detail(candidate) {
+  return (candidate.title !== undefined ? 1 : 0) + (candidate.isForum !== undefined ? 1 : 0);
+}
+function discoverTelegramTargets(updates) {
+  const chats = new Map;
+  const users = new Map;
+  if (!Array.isArray(updates))
+    return { chats: [], users: [] };
+  const noteChat = (raw) => {
+    const chat = readChat(raw);
+    if (chat === undefined || !chat.type.includes("group"))
+      return;
+    const seen = chats.get(chat.id);
+    if (seen === undefined || detail(chat) > detail(seen))
+      chats.set(chat.id, chat);
+  };
+  const noteUser = (raw) => {
+    const user = readUser(raw);
+    if (user !== undefined && !users.has(user.id))
+      users.set(user.id, user);
+  };
+  for (const update of updates) {
+    if (!isRecord(update))
+      continue;
+    for (const key of CHAT_CARRIERS) {
+      const carrier = update[key];
+      if (!isRecord(carrier))
+        continue;
+      noteChat(carrier["chat"]);
+      noteUser(carrier["from"]);
+    }
+    const callback = update["callback_query"];
+    if (isRecord(callback)) {
+      noteUser(callback["from"]);
+      const message = callback["message"];
+      if (isRecord(message))
+        noteChat(message["chat"]);
+    }
+  }
+  return { chats: [...chats.values()], users: [...users.values()] };
+}
+var CHAT_CARRIERS;
+var init_telegram_discovery = __esm(() => {
+  CHAT_CARRIERS = ["message", "edited_message", "channel_post", "edited_channel_post", "my_chat_member"];
+});
+
+// packages/core/src/codex-hooks.ts
+import { createHash } from "crypto";
+function quoteToken(token) {
+  if (token !== "" && !/[ \t"]/.test(token))
+    return token;
+  return `"${token.replaceAll('"', "\\\"")}"`;
+}
+function buildCodexHooks(input) {
+  const command = [input.command, ...input.args].map(quoteToken).join(" ");
+  const group = (timeout) => [
+    { hooks: [{ type: "command", command, timeout, async: false }] }
+  ];
+  const hooks = {};
+  for (const event of OBSERVATION_EVENTS)
+    hooks[event] = group(input.timeoutSeconds ?? OBSERVATION_TIMEOUT_SECONDS);
+  hooks["PermissionRequest"] = group(CODEX_PERMISSION_TIMEOUT_SECONDS);
+  hooks["SessionEnd"] = group(SESSION_END_TIMEOUT_SECONDS);
+  return { hooks };
+}
+function normalizedTimeout(event, timeout) {
+  if (event === "SessionEnd")
+    return Math.min(3, Math.max(1, timeout));
+  return Math.max(1, timeout);
+}
+function canonicalJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function codexHookTrust(hooksJsonPath, file) {
+  const entries = [];
+  for (const [event, groups] of Object.entries(file.hooks)) {
+    const label = EVENT_KEY_LABELS[event];
+    if (label === undefined)
+      continue;
+    groups.forEach((group, groupIndex) => {
+      group.hooks.forEach((hook, hookIndex) => {
+        const identity = {
+          event_name: label,
+          ...group.matcher !== undefined ? { matcher: group.matcher } : {},
+          hooks: [
+            {
+              type: "command",
+              command: hook.command,
+              timeout: normalizedTimeout(event, hook.timeout),
+              async: hook.async
+            }
+          ]
+        };
+        const hash = `sha256:${createHash("sha256").update(canonicalJson(identity)).digest("hex")}`;
+        entries.push({ key: `${hooksJsonPath}:${label}:${groupIndex}:${hookIndex}`, hash });
+      });
+    });
+  }
+  return entries;
+}
+function codexTrustStateToml(entries) {
+  return entries.map((e) => {
+    const key = e.key.replaceAll("\\", "\\\\").replaceAll('"', "\\\"");
+    return `[hooks.state."${key}"]
+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" } } };
@@ -2346,6 +3183,19 @@ function errorText(value) {
     return message.slice(0, MAX_RESULT_TEXT2);
   return llmContentText(value);
 }
+function permissionToolName(details) {
+  if (!isRecord(details))
+    return;
+  const pick = (key) => {
+    const value = details[key];
+    return typeof value === "string" && value !== "" ? value : undefined;
+  };
+  if (details["type"] === "mcp")
+    return pick("toolName") ?? pick("toolDisplayName") ?? pick("title");
+  if (details["type"] === "exec")
+    return pick("rootCommand") ?? pick("command") ?? pick("title");
+  return pick("title");
+}
 function mapGeminiHook(input) {
   switch (input.hook_event_name) {
     case "SessionStart":
@@ -2378,15 +3228,17 @@ function mapGeminiHook(input) {
       }
       return out;
     }
-    case "Notification":
+    case "Notification": {
       if (input.notification_type !== "ToolPermission")
         return [];
+      const toolName = permissionToolName(input.details);
       return [
         {
           event: "tool_approval_requested",
-          ...input.tool_name !== undefined ? { tool_name: input.tool_name } : {}
+          ...toolName !== undefined ? { tool_name: toolName } : {}
         }
       ];
+    }
     case "AfterAgent": {
       const out = [];
       const text = input.prompt_response;
@@ -2418,7 +3270,10 @@ function buildGeminiSettings(input) {
   const hooks = {};
   for (const event of GEMINI_EVENTS)
     hooks[event] = [{ hooks: [handler] }];
-  return { hooks };
+  return {
+    hooks,
+    ...input.mcp === undefined ? {} : { mcpServers: { [MCP_SERVER_NAME]: mcpServerEntry(input.mcp, input.mcpContextPath) } }
+  };
 }
 var MAX_RESULT_TEXT2 = 2000, HOOK_TIMEOUT_MS = 2000, GEMINI_EVENTS;
 var init_gemini_hooks = __esm(() => {
@@ -2433,65 +3288,6 @@ var init_gemini_hooks = __esm(() => {
   ];
 });
 
-// packages/core/src/agent-launch.ts
-function uuidFromSessionId(sessionId) {
-  const hex = sessionId.replace(/-/g, "");
-  if (hex.length !== 32)
-    throw new Error(`session id is not 32 hex characters: ${sessionId}`);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function buildAgentCommand(input) {
-  const extra = [...input.extraArgs ?? []];
-  if (input.agent === "claude") {
-    return [
-      "claude",
-      "--settings",
-      input.claudeSettingsPath,
-      "--session-id",
-      uuidFromSessionId(input.sessionId),
-      ...extra
-    ];
-  }
-  if (input.agent === "gemini") {
-    return [
-      "gemini",
-      "--session-id",
-      input.sessionId,
-      ...extra
-    ];
-  }
-  if (input.agent === "codex") {
-    return ["codex", ...extra];
-  }
-  return ["omp", "--extension", input.extensionPath, ...extra];
-}
-function buildAgentResumeCommand(input) {
-  if (input.agent === "claude") {
-    return [
-      "claude",
-      "--settings",
-      input.claudeSettingsPath,
-      "--resume",
-      uuidFromSessionId(input.sessionId),
-      ...input.extraArgs ?? []
-    ];
-  }
-  if (input.agent === "gemini") {
-    return ["gemini", "--resume", input.sessionId, ...input.extraArgs ?? []];
-  }
-  return buildAgentCommand(input);
-}
-function isAgentId(value) {
-  return AGENT_IDS.includes(value);
-}
-function supportedAgents() {
-  return AGENT_IDS;
-}
-var AGENT_IDS;
-var init_agent_launch = __esm(() => {
-  AGENT_IDS = ["omp", "claude", "codex", "gemini"];
-});
-
 // packages/core/src/dotenv-scrub.ts
 function dotenvCandidates(nodeEnv) {
   const mode = nodeEnv === undefined || nodeEnv === "" ? "development" : nodeEnv;
@@ -2543,21 +3339,6 @@ var init_dotenv_scrub = __esm(() => {
   LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/;
 });
 
-// packages/core/src/duration.ts
-function humanDuration(ms) {
-  if (!Number.isFinite(ms) || ms <= 0)
-    return "0s";
-  const seconds = Math.max(1, Math.round(ms / 1000));
-  if (seconds < 60)
-    return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60)
-    return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  const rest = minutes % 60;
-  return rest === 0 ? `${hours}h` : `${hours}h ${rest}m`;
-}
-
 // packages/core/src/idle-screen.ts
 function screenHash(screen) {
   const normalised = screen.split(`
@@ -2633,6 +3414,24 @@ function sessionInScope(session, scope, resolve = asGiven) {
 function sessionsInScope(sessions, scope, resolve = asGiven) {
   return sessions.filter((session) => sessionInScope(session, scope, resolve));
 }
+function mostRecentSession(sessions) {
+  let newest;
+  for (const session of sessions) {
+    if (session.state === "exited")
+      continue;
+    if (newest === undefined || session.createdAt > newest.createdAt)
+      newest = session;
+  }
+  return newest;
+}
+function sessionsByRecency(live, stored) {
+  const byId = new Map;
+  for (const session of stored)
+    byId.set(session.id, session);
+  for (const session of live)
+    byId.set(session.id, session);
+  return [...byId.values()].sort((a, b) => b.createdAt - a.createdAt);
+}
 var asGiven = (target) => target;
 var init_session_scope = () => {};
 
@@ -2665,8 +3464,16 @@ var init_src = __esm(() => {
   init_agent_status();
   init_activity();
   init_claude_hooks();
-  init_gemini_onboarding();
+  init_onboarding();
   init_doctor();
+  init_stall();
+  init_codex_stream();
+  init_keys();
+  init_quota();
+  init_gemini_telemetry();
+  init_mcp_ask();
+  init_store_quota();
+  init_telegram_discovery();
   init_codex_hooks();
   init_gemini_hooks();
   init_agent_launch();
@@ -2678,14 +3485,14 @@ var init_src = __esm(() => {
 });
 
 // packages/daemon/src/config-store.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 function writeAtomic(target, contents, mode) {
   const tmp = `${target}.tmp`;
-  fs4.writeFileSync(tmp, contents, { mode });
-  fs4.renameSync(tmp, target);
+  fs5.writeFileSync(tmp, contents, { mode });
+  fs5.renameSync(tmp, target);
   if (process.platform !== "win32")
-    fs4.chmodSync(target, mode);
+    fs5.chmodSync(target, mode);
 }
 
 class ConfigStore {
@@ -2701,16 +3508,16 @@ class ConfigStore {
   }
   load() {
     this.loadError = undefined;
-    fs4.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
+    fs5.mkdirSync(this.paths.configDir, { recursive: true, mode: DIR_MODE });
     if (process.platform !== "win32") {
       try {
-        fs4.chmodSync(this.paths.configDir, DIR_MODE);
+        fs5.chmodSync(this.paths.configDir, DIR_MODE);
       } catch {}
     }
     this.config = structuredClone(DEFAULT_CONFIG);
-    if (fs4.existsSync(this.paths.configFile)) {
+    if (fs5.existsSync(this.paths.configFile)) {
       try {
-        const parsed = parseConfig(JSON.parse(fs4.readFileSync(this.paths.configFile, "utf8")));
+        const parsed = parseConfig(JSON.parse(fs5.readFileSync(this.paths.configFile, "utf8")));
         if ("errors" in parsed)
           this.loadError = parsed.errors.join("; ");
         else
@@ -2720,10 +3527,10 @@ class ConfigStore {
       }
     }
     this.secrets = {};
-    if (fs4.existsSync(this.paths.secretsFile)) {
+    if (fs5.existsSync(this.paths.secretsFile)) {
       this.tightenPermissions(this.paths.secretsFile);
       try {
-        const raw = JSON.parse(fs4.readFileSync(this.paths.secretsFile, "utf8"));
+        const raw = JSON.parse(fs5.readFileSync(this.paths.secretsFile, "utf8"));
         if (raw !== null && typeof raw === "object") {
           for (const [key, value] of Object.entries(raw)) {
             if (typeof value === "string")
@@ -2739,8 +3546,8 @@ class ConfigStore {
     if (process.platform === "win32")
       return;
     try {
-      if ((fs4.statSync(file).mode & 63) !== 0)
-        fs4.chmodSync(file, FILE_MODE);
+      if ((fs5.statSync(file).mode & 63) !== 0)
+        fs5.chmodSync(file, FILE_MODE);
     } catch {}
   }
   get() {
@@ -2748,7 +3555,7 @@ class ConfigStore {
   }
   health() {
     return configHealth({
-      fileExists: fs4.existsSync(this.paths.configFile),
+      fileExists: fs5.existsSync(this.paths.configFile),
       parseError: this.loadError,
       config: this.resolved()
     });
@@ -2793,7 +3600,7 @@ class ConfigStore {
       delete this.secrets[dottedPath];
     else
       this.secrets[dottedPath] = value;
-    if (!fs4.existsSync(this.paths.configFile)) {
+    if (!fs5.existsSync(this.paths.configFile)) {
       writeAtomic(this.paths.configFile, `${JSON.stringify(this.config, null, 2)}
 `, FILE_MODE);
     }
@@ -2823,7 +3630,7 @@ class ConfigStore {
   fingerprint() {
     const stamp = (file) => {
       try {
-        return String(fs4.statSync(file).mtimeMs);
+        return String(fs5.statSync(file).mtimeMs);
       } catch {
         return "-";
       }
@@ -2845,8 +3652,8 @@ function applyPath(config, dottedPath, value) {
 function defaultConfigStorePaths(configDir) {
   return {
     configDir,
-    configFile: path5.join(configDir, "config.json"),
-    secretsFile: path5.join(configDir, "secrets.json")
+    configFile: path6.join(configDir, "config.json"),
+    secretsFile: path6.join(configDir, "secrets.json")
   };
 }
 var ENV_ALIASES, DIR_MODE = 448, FILE_MODE = 384;
@@ -2865,13 +3672,13 @@ var init_config_store = __esm(() => {
 });
 
 // packages/daemon/src/shell.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function findExecutable(name, env) {
   const isWindows = env.platform === "win32";
-  const join = isWindows ? path6.win32.join : path6.posix.join;
+  const join = isWindows ? path7.win32.join : path7.posix.join;
   const separator = isWindows ? ";" : ":";
-  const extensions = isWindows ? path6.win32.extname(name).length > 0 ? [""] : env.pathExt.split(";").filter((e) => e.length > 0) : [""];
+  const extensions = isWindows ? path7.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)
@@ -2889,16 +3696,16 @@ function lookupOnPath(name) {
     platform: process.platform,
     pathEnv: process.env["PATH"] ?? "",
     pathExt: process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD",
-    exists: (candidate) => fs5.existsSync(candidate)
+    exists: (candidate) => fs6.existsSync(candidate)
   });
 }
 function resolveShell(kind) {
   if (process.platform !== "win32")
     return resolvePosixShell(kind);
   const systemRoot = process.env["SystemRoot"] ?? "C:\\Windows";
-  const windowsPowershell = path6.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  const windowsPowershell = path7.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
   if (kind === "cmd") {
-    return { kind: "cmd", exe: path6.join(systemRoot, "System32", "cmd.exe") };
+    return { kind: "cmd", exe: path7.join(systemRoot, "System32", "cmd.exe") };
   }
   if (kind === "powershell") {
     return { kind: "powershell", exe: windowsPowershell };
@@ -2926,7 +3733,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) => fs5.existsSync(c.exe));
+  const found = candidates.find((c) => fs6.existsSync(c.exe));
   if (found)
     return found;
   return { kind: "sh", exe: "/bin/sh" };
@@ -2971,24 +3778,24 @@ function ipcEndpoint(platform, user, env) {
     const suffix = `-${shortHash(env.runtimeDir)}`;
     return `\\\\.\\pipe\\axterm-${safeUser}${suffix}`;
   }
-  return path6.posix.join(env.runtimeDir, "axterm.sock");
+  return path7.posix.join(env.runtimeDir, "axterm.sock");
 }
 var cachedPwsh;
 var init_shell = () => {};
-
-// packages/daemon/src/paths.ts
-import fs6 from "fs";
-import os4 from "os";
-import path7 from "path";
+
+// packages/daemon/src/paths.ts
+import fs7 from "fs";
+import os3 from "os";
+import path8 from "path";
 function ensureDataDirs() {
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir, SCROLLBACK_DIR, LOG_DIR, EXT_DIR]) {
-    fs6.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
+    fs7.mkdirSync(dir, { recursive: true, mode: DIR_MODE2 });
   }
   if (process.platform === "win32")
     return;
   for (const dir of [PATHS.configDir, PATHS.stateDir, PATHS.runtimeDir]) {
     try {
-      fs6.chmodSync(dir, DIR_MODE2);
+      fs7.chmodSync(dir, DIR_MODE2);
     } catch {}
   }
 }
@@ -2996,14 +3803,14 @@ function restrictFile(file) {
   if (process.platform === "win32")
     return;
   try {
-    fs6.chmodSync(file, 384);
+    fs7.chmodSync(file, 384);
   } catch {}
 }
 function log(message) {
   const line = `${new Date().toISOString()} ${message}
 `;
   try {
-    fs6.appendFileSync(LOG_FILE, line);
+    fs7.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;
@@ -3020,15 +3827,15 @@ var init_paths = __esm(() => {
   DB_PATH = PATHS.dbFile;
   RUNTIME_FILE2 = PATHS.runtimeFile;
   HOOK_ENDPOINT_FILE = PATHS.hookEndpointFile;
-  PIPE_PATH = ipcEndpoint(process.platform, os4.userInfo().username, {
+  PIPE_PATH = ipcEndpoint(process.platform, os3.userInfo().username, {
     runtimeDir: PATHS.runtimeDir
   });
-  LOG_FILE = path7.join(LOG_DIR, "daemon.log");
+  LOG_FILE = path8.join(LOG_DIR, "daemon.log");
 });
 
 // packages/daemon/src/store.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { Database } from "bun:sqlite";
 function rowToInfo(row) {
   return {
@@ -3059,7 +3866,7 @@ function rowToInfo(row) {
 class Store {
   db;
   constructor(dbPath = DB_PATH) {
-    fs7.mkdirSync(path8.dirname(dbPath), { recursive: true });
+    fs8.mkdirSync(path9.dirname(dbPath), { recursive: true });
     this.db = new Database(dbPath, { strict: true });
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`
@@ -3220,11 +4027,11 @@ var init_store = __esm(() => {
 });
 
 // packages/daemon/src/config-migrate.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 import { Database as Database2 } from "bun:sqlite";
 function checkpointWal(dbFile) {
-  if (!fs8.existsSync(dbFile))
+  if (!fs9.existsSync(dbFile))
     return;
   try {
     const db = new Database2(dbFile);
@@ -3234,32 +4041,32 @@ function checkpointWal(dbFile) {
 }
 function relocate(source, target) {
   try {
-    fs8.renameSync(source, target);
+    fs9.renameSync(source, target);
   } catch {
-    fs8.cpSync(source, target, { recursive: true });
+    fs9.cpSync(source, target, { recursive: true });
   }
 }
 function moveInto(from, to, notes) {
-  checkpointWal(path9.join(from, "axterm.db"));
-  fs8.mkdirSync(to, { recursive: true });
+  checkpointWal(path10.join(from, "axterm.db"));
+  fs9.mkdirSync(to, { recursive: true });
   for (const entry of STATE_ENTRIES) {
-    const source = path9.join(from, entry);
-    const target = path9.join(to, entry);
-    if (!fs8.existsSync(source))
+    const source = path10.join(from, entry);
+    const target = path10.join(to, entry);
+    if (!fs9.existsSync(source))
       continue;
-    if (!fs8.existsSync(target)) {
+    if (!fs9.existsSync(target)) {
       relocate(source, target);
       notes.push(`moved ${entry}`);
       continue;
     }
-    if (!fs8.statSync(source).isDirectory() || !fs8.statSync(target).isDirectory())
+    if (!fs9.statSync(source).isDirectory() || !fs9.statSync(target).isDirectory())
       continue;
     let moved = 0;
-    for (const child of fs8.readdirSync(source)) {
-      const childTarget = path9.join(target, child);
-      if (fs8.existsSync(childTarget))
+    for (const child of fs9.readdirSync(source)) {
+      const childTarget = path10.join(target, child);
+      if (fs9.existsSync(childTarget))
         continue;
-      relocate(path9.join(source, child), childTarget);
+      relocate(path10.join(source, child), childTarget);
       moved += 1;
     }
     if (moved > 0)
@@ -3269,29 +4076,29 @@ function moveInto(from, to, notes) {
 function migrateLegacyConfig(input) {
   const notes = [];
   const storePaths = defaultConfigStorePaths(input.configDir);
-  if (fs8.existsSync(storePaths.configFile))
+  if (fs9.existsSync(storePaths.configFile))
     return { migrated: false, notes };
-  const configSource = input.legacyRoots.find((dir) => fs8.existsSync(path9.join(dir, "config.json")));
+  const configSource = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "config.json")));
   if (configSource !== undefined) {
-    fs8.mkdirSync(input.configDir, { recursive: true });
-    fs8.copyFileSync(path9.join(configSource, "config.json"), storePaths.configFile);
-    const secrets = path9.join(configSource, "secrets.json");
-    if (fs8.existsSync(secrets)) {
-      fs8.copyFileSync(secrets, storePaths.secretsFile);
+    fs9.mkdirSync(input.configDir, { recursive: true });
+    fs9.copyFileSync(path10.join(configSource, "config.json"), storePaths.configFile);
+    const secrets = path10.join(configSource, "secrets.json");
+    if (fs9.existsSync(secrets)) {
+      fs9.copyFileSync(secrets, storePaths.secretsFile);
       try {
-        fs8.chmodSync(storePaths.secretsFile, 384);
+        fs9.chmodSync(storePaths.secretsFile, 384);
       } catch {}
     }
-    fs8.writeFileSync(path9.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
+    fs9.writeFileSync(path10.join(configSource, "MIGRATED.txt"), `axterm now reads its configuration from:
   ${input.configDir}
 ` + `These files are no longer used. secrets.json still holds your bot token \u2014 delete this directory once you are satisfied.
 `);
     notes.push(`adopted configuration from ${configSource}`);
   }
-  const legacy = input.legacyRoots.find((dir) => fs8.existsSync(path9.join(dir, "axterm.db")));
+  const legacy = input.legacyRoots.find((dir) => fs9.existsSync(path10.join(dir, "axterm.db")));
   if (legacy !== undefined) {
     moveInto(legacy, input.stateDir, notes);
-    fs8.writeFileSync(path9.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
+    fs9.writeFileSync(path10.join(legacy, "MIGRATED.txt"), `axterm now stores state in:
   ${input.stateDir}
 and configuration in:
   ${input.configDir}
@@ -3300,8 +4107,8 @@ and configuration in:
   }
   if (configSource !== undefined)
     return { migrated: true, ...legacy ? { from: legacy } : {}, notes };
-  const dbFile = path9.join(input.stateDir, "axterm.db");
-  if (!fs8.existsSync(dbFile))
+  const dbFile = path10.join(input.stateDir, "axterm.db");
+  if (!fs9.existsSync(dbFile))
     return { migrated: notes.length > 0, ...legacy ? { from: legacy } : {}, notes };
   const store = new Store(dbFile);
   const machine2 = store.getConfig("axterm_machine");
@@ -3346,6 +4153,7 @@ var axterm_agent_status_default = `// @axterm-managed-omp-extension\r
 // completion) follow Orca's production orca-agent-status.ts, reviewed in\r
 // docs/design/terminal-wrapper-omp-telegram.md \xA75.\r
 import fs from "node:fs";\r
+import path from "node:path";\r
 \r
 const HOOK_POST_TIMEOUT_MS = 1000;\r
 const MAX_ASSISTANT_TEXT = 4000;\r
@@ -3541,11 +4349,75 @@ function formatAnswers(params: unknown, answers: AskAnswerWire[]): Record<string
 }\r
 \r
 export default function axtermAgentStatus(pi: PiLike): void {\r
-  // Subagents inherit the lead's env; only one process may report.\r
+  // Only one PROCESS may report. This catches an agent that spawns another\r
+  // agent as a child process; it does NOT catch omp's own subagents, which are\r
+  // \`AgentSession\`s inside THIS process \u2014 \`process.pid\` is identical for them,\r
+  // so they fall straight through. Telling those apart needs the session id,\r
+  // which \`isLeadSession\` below does per event.\r
   const owner = process.env["AXTERM_STATUS_OWNED"];\r
   const selfPid = String(process.pid);\r
   if (owner && owner !== selfPid) return;\r
   process.env["AXTERM_STATUS_OWNED"] = selfPid;\r
+\r
+  /* ----------------------- lead versus subagent ------------------------ */\r
+  // omp loads this extension into every AgentSession, and every handler gets\r
+  // the same ExtensionContext \u2014 \`sessionManager.getSessionId()\` is available on\r
+  // all of them (verified in the installed omp's types). Only the shutdown\r
+  // handler used it, so a finishing SUBAGENT posted \`agent_end\`: the session\r
+  // flipped to \`done\`, Telegram announced it and renamed the topic, while the\r
+  // lead was still working.\r
+  //\r
+  // The first session to start in the process is the lead \u2014 a subagent cannot\r
+  // begin before its parent. Recorded in \`process.env\` rather than a module\r
+  // variable because that is the one channel guaranteed to be shared no matter\r
+  // how omp instantiates the module, which is why the PID guard above uses it\r
+  // too.\r
+  const LEAD_KEY = "AXTERM_LEAD_SESSION";\r
+\r
+  function sessionIdOf(ctx: unknown): string | undefined {\r
+    const manager = (ctx as { sessionManager?: { getSessionId?: () => string } } | undefined)?.sessionManager;\r
+    try {\r
+      return manager?.getSessionId?.();\r
+    } catch {\r
+      return undefined;\r
+    }\r
+  }\r
+\r
+  /**\r
+   * Claim lead on the first \`session_start\` seen in this process. A subagent\r
+   * cannot begin before its parent, so first is the lead \u2014 and recording it\r
+   * here rather than lazily on the first judgement matters: a subagent's\r
+   * completion would otherwise be the first caller and crown itself.\r
+   */\r
+  function rememberLead(ctx: unknown): void {\r
+    const id = sessionIdOf(ctx);\r
+    if (id === undefined) return;\r
+    if (!process.env[LEAD_KEY]) process.env[LEAD_KEY] = id;\r
+  }\r
+\r
+  /**\r
+   * Fails OPEN twice over \u2014 no lead recorded, or no id on this event. A build\r
+   * that exposes neither must not lose its turn-end entirely, which would leave\r
+   * the session at \`working\` forever; the shutdown path makes the same choice\r
+   * (\xA74.42).\r
+   */\r
+  function isLeadSession(ctx: unknown): boolean {\r
+    const lead = process.env[LEAD_KEY];\r
+    if (!lead) return true;\r
+    const id = sessionIdOf(ctx);\r
+    return id === undefined || id === lead;\r
+  }\r
+\r
+  /**\r
+   * A switch or a branch makes another session the one the operator is driving,\r
+   * so it becomes the lead \u2014 force, not first-wins. Without this the gate would\r
+   * treat the new foreground session as a subagent and the session would never\r
+   * report a completed turn again, which is worse than the leak it prevents.\r
+   */\r
+  function claimLead(ctx: unknown): void {\r
+    const id = sessionIdOf(ctx);\r
+    if (id !== undefined) process.env[LEAD_KEY] = id;\r
+  }\r
 \r
   /* ---------------- endpoint re-sourcing (env-freeze fix) ---------------- */\r
   let warnedBadEndpoint = false;\r
@@ -3774,6 +4646,12 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
         const say = (text: string, isError = false) => ({ content: [{ type: "text" as const, text }], isError });\r
         const { path: filePath, caption } = (params ?? {}) as { path?: string; caption?: string };\r
         if (!filePath) return say("no path given", true);\r
+        // Resolved HERE, because this process is the only one standing in the\r
+        // right directory. The daemon interprets what it receives against its\r
+        // own cwd \u2014 wherever it was spawned, never the session's folder \u2014 so a\r
+        // bare filename came back "file not found" while the file was plainly\r
+        // there. An absolute path is passed through untouched.\r
+        const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath);\r
         const coords = resolveCoords();\r
         const sessionId = process.env["AXTERM_SESSION_ID"];\r
         if (!coords.port || !coords.token || !sessionId) {\r
@@ -3786,7 +4664,7 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
             body: JSON.stringify({\r
               sessionId,\r
               launchToken: process.env["AXTERM_LAUNCH_TOKEN"] ?? "",\r
-              path: filePath,\r
+              path: resolved,\r
               caption,\r
             }),\r
           });\r
@@ -3810,7 +4688,7 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
       return { status: "no-channel" };\r
     }\r
     try {\r
-      const res = await fetch(\`http://127.0.0.1:\${coords.port}/hook/omp/ask\`, {\r
+      const res = await fetch(\`http://127.0.0.1:\${coords.port}/hook/ask\`, {\r
         method: "POST",\r
         headers: { "content-type": "application/json", "x-axterm-hook-token": coords.token },\r
         body: JSON.stringify({\r
@@ -3833,7 +4711,7 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
     const sessionId = process.env["AXTERM_SESSION_ID"];\r
     if (!coords.port || !coords.token || !sessionId) return;\r
     try {\r
-      await fetch(\`http://127.0.0.1:\${coords.port}/hook/omp/ask-cancel\`, {\r
+      await fetch(\`http://127.0.0.1:\${coords.port}/hook/ask-cancel\`, {\r
         method: "POST",\r
         headers: { "content-type": "application/json", "x-axterm-hook-token": coords.token },\r
         body: JSON.stringify({ sessionId, launchToken: process.env["AXTERM_LAUNCH_TOKEN"] ?? "", askId }),\r
@@ -3845,6 +4723,8 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
 \r
   /* ------------------------------ handlers ------------------------------ */\r
   pi.on("session_start", (_event, ctx) => {\r
+    // First one wins, and it decides who may end a turn from here on.\r
+    rememberLead(ctx);\r
     const manager = (ctx as { sessionManager?: Record<string, unknown> } | undefined)?.sessionManager;\r
     const probe = (names: string[]): unknown => {\r
       for (const name of names) {\r
@@ -3867,7 +4747,16 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
     });\r
   });\r
 \r
-  pi.on("before_agent_start", (event) => {\r
+  // Switching or branching inside omp changes which session the operator is\r
+  // driving. Not reported to the daemon \u2014 the session row is unchanged \u2014 but the\r
+  // lead has to follow, or turn ends stop arriving from here on.\r
+  pi.on("session_switch", (_event, ctx) => claimLead(ctx));\r
+  pi.on("session_branch", (_event, ctx) => claimLead(ctx));\r
+\r
+  // Lead only: this sets the run's starting prompt, which the channel shows in\r
+  // the topic title. A subagent's own prompt is not what the operator asked.\r
+  pi.on("before_agent_start", (event, ctx) => {\r
+    if (!isLeadSession(ctx)) return;\r
     post("before_agent_start", { prompt: (event as { prompt?: string } | undefined)?.prompt ?? "" });\r
   });\r
 \r
@@ -3912,7 +4801,10 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
     recheckMs = Math.min(recheckMs * 2, IDLE_RECHECK_MAX_MS);\r
   }\r
 \r
-  pi.on("agent_start", () => {\r
+  // Lead only: a subagent starting is not the session's turn restarting, and\r
+  // resetting \`endReported\` here on its behalf would arm a second completion.\r
+  pi.on("agent_start", (_event, ctx) => {\r
+    if (!isLeadSession(ctx)) return;\r
     clearPendingCheck();\r
     endReported = false;\r
     post("agent_start");\r
@@ -3997,20 +4889,29 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
     });\r
   });\r
 \r
-  pi.on("message_end", (event) => {\r
+  // Lead only: this becomes the session's \`lastReply\` \u2014 the answer the channel\r
+  // shows. A subagent's internal message is not the session's answer.\r
+  pi.on("message_end", (event, ctx) => {\r
+    if (!isLeadSession(ctx)) return;\r
     const message = (event as { message?: unknown } | undefined)?.message;\r
     const text = extractAssistantText(message);\r
     if (!text) return;\r
     post("message_end", { role: "assistant", text });\r
   });\r
 \r
-  pi.on("agent_settled", () => {\r
+  // Lead only, and this is the one the report was about: a finishing subagent\r
+  // announced the turn as done and renamed the topic while the lead worked on.\r
+  pi.on("agent_settled", (_event, ctx) => {\r
+    if (!isLeadSession(ctx)) return;\r
     settledSupported = true;\r
     clearPendingCheck();\r
     postEndOnce();\r
   });\r
 \r
+  // The other route to a turn end, for builds without \`agent_settled\`. Gated the\r
+  // same way, or a subagent whose own work is idle ends the session's turn.\r
   pi.on("agent_end", (_event, ctx) => {\r
+    if (!isLeadSession(ctx)) return;\r
     if (settledSupported) return;\r
     const c = ctx as { isIdle?: () => boolean } | undefined;\r
     if (!c || typeof c.isIdle !== "function") {\r
@@ -4045,13 +4946,13 @@ export default function axtermAgentStatus(pi: PiLike): void {\r
 var init_axterm_agent_status = () => {};
 
 // packages/daemon/src/ext-install.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function installExtensionAsset(targetDir) {
-  fs9.mkdirSync(targetDir, { recursive: true });
-  const target = path10.join(targetDir, "axterm-agent-status.mjs");
+  fs10.mkdirSync(targetDir, { recursive: true });
+  const target = path11.join(targetDir, "axterm-agent-status.mjs");
   const js = new Bun.Transpiler({ loader: "ts" }).transformSync(extensionSource);
-  fs9.writeFileSync(target, MANAGED_HEADER + js);
+  fs10.writeFileSync(target, MANAGED_HEADER + js);
   return target;
 }
 var extensionSource, MANAGED_HEADER = `// @axterm-managed-omp-extension
@@ -4064,8 +4965,8 @@ var init_ext_install = __esm(() => {
 
 // packages/daemon/src/workspace-local.ts
 import { spawn as spawn2 } from "child_process";
-import fs10 from "fs/promises";
-import path11 from "path";
+import fs11 from "fs/promises";
+import path12 from "path";
 function isAbsent(error) {
   const code = error?.code;
   return code === "ENOENT" || code === "ENOTDIR";
@@ -4078,10 +4979,10 @@ class LocalWorkspace {
     this.stagingDir = stagingDir;
   }
   async list(dir) {
-    const dirents = await fs10.readdir(dir, { withFileTypes: true });
+    const dirents = await fs11.readdir(dir, { withFileTypes: true });
     const stats = await Promise.all(dirents.map(async (dirent) => {
       try {
-        return await fs10.lstat(path11.join(dir, dirent.name));
+        return await fs11.lstat(path12.join(dir, dirent.name));
       } catch (error) {
         if (isAbsent(error))
           return;
@@ -4105,7 +5006,7 @@ class LocalWorkspace {
   }
   async stat(target) {
     try {
-      const stat = await fs10.stat(target);
+      const stat = await fs11.stat(target);
       const kind = stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
       return { kind, size: stat.size, mtimeMs: stat.mtimeMs };
     } catch (error) {
@@ -4116,8 +5017,8 @@ class LocalWorkspace {
   }
   async read(file, limit) {
     if (limit === undefined)
-      return await fs10.readFile(file);
-    const handle = await fs10.open(file, "r");
+      return await fs11.readFile(file);
+    const handle = await fs11.open(file, "r");
     try {
       const buffer = Buffer.allocUnsafe(Math.min(limit, (await handle.stat()).size));
       let filled = 0;
@@ -4162,9 +5063,9 @@ var init_workspace_local = () => {};
 
 // packages/daemon/src/hook-host.ts
 import { randomBytes } from "crypto";
-import fs11 from "fs";
+import fs12 from "fs";
 import http from "http";
-import path12 from "path";
+import path13 from "path";
 function header(req, name) {
   const value = req.headers[name];
   return Array.isArray(value) ? value[0] : value;
@@ -4188,7 +5089,7 @@ class HookHost {
   constructor(options) {
     this.endpointFile = options.endpointFile;
     this.codexApprovalHoldMs = options.codexApprovalHoldMs ?? CODEX_APPROVAL_HOLD_MS;
-    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path12.join(RUNTIME_DIR, "materialised")));
+    this.resolveWorkspace = options.workspaceFor ?? (() => this.local ??= new LocalWorkspace(path13.join(RUNTIME_DIR, "materialised")));
   }
   start() {
     const server = http.createServer((req, res) => this.handle(req, res));
@@ -4204,12 +5105,12 @@ class HookHost {
     return promise;
   }
   writeEndpointFile(port) {
-    fs11.mkdirSync(path12.dirname(this.endpointFile), { recursive: true });
+    fs12.mkdirSync(path13.dirname(this.endpointFile), { recursive: true });
     const tmp = `${this.endpointFile}.tmp`;
-    fs11.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
+    fs12.writeFileSync(tmp, `AXTERM_HOOK_PORT=${port}
 AXTERM_HOOK_TOKEN=${this.token}
 `);
-    fs11.renameSync(tmp, this.endpointFile);
+    fs12.renameSync(tmp, this.endpointFile);
   }
   registerSession(sessionId, launchToken, onEvent) {
     this.sessions.set(sessionId, { launchToken, onEvent });
@@ -4247,8 +5148,8 @@ AXTERM_HOOK_TOKEN=${this.token}
   }
   handle(req, res) {
     const isEvent = req.url === "/hook/omp";
-    const isAsk = req.url === "/hook/omp/ask";
-    const isAskCancel = req.url === "/hook/omp/ask-cancel";
+    const isAsk = req.url === "/hook/ask";
+    const isAskCancel = req.url === "/hook/ask-cancel";
     const isAttach = req.url === "/hook/attach";
     const isClaude = req.url === "/hook/claude";
     const isCodex = req.url === "/hook/codex";
@@ -4484,7 +5385,7 @@ var init_hook_host = __esm(() => {
 });
 
 // packages/daemon/src/rpc-server.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import net2 from "net";
 function writeFrame(socket, frame) {
   if (!socket.destroyed)
@@ -4669,10 +5570,12 @@ function startRpcServer(options) {
         }
         case "config.set": {
           const dottedPath = p["path"];
-          if (isSecretPath(dottedPath))
-            config.setSecret(dottedPath, p["value"]);
-          else {
-            const next2 = setConfigValue(config.get(), dottedPath, p["value"]);
+          const raw = p["value"];
+          const value = Array.isArray(raw) ? raw : raw;
+          if (isSecretPath(dottedPath)) {
+            config.setSecret(dottedPath, Array.isArray(value) ? value.join(" ") : value);
+          } else {
+            const next2 = setConfigValue(config.get(), dottedPath, value);
             if ("error" in next2)
               throw new Error(next2.error);
             config.update(() => next2.config);
@@ -4700,10 +5603,14 @@ function startRpcServer(options) {
         }
         case "telegram.doctor":
           return telegram.doctor();
+        case "telegram.discover":
+          return telegram.discover(p["botToken"]);
         case "telegram.status":
           return telegram.status();
         case "doctor.report":
           return { checks: manager.doctorReport() };
+        case "quota.report":
+          return { checks: manager.quotaReport() };
         case "daemon.stop":
           setTimeout(onStopRequested, 50);
           return {};
@@ -4714,7 +5621,7 @@ function startRpcServer(options) {
   });
   if (process.platform !== "win32") {
     try {
-      fs12.unlinkSync(pipePath);
+      fs13.unlinkSync(pipePath);
     } catch {}
   }
   server.listen(pipePath, () => {
@@ -4729,17 +5636,17 @@ var init_rpc_server = __esm(() => {
 });
 
 // packages/daemon/src/codex-home.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 function codexTrustKeyPath(home) {
   const resolved = (() => {
     try {
-      return fs13.realpathSync.native(home);
+      return fs14.realpathSync.native(home);
     } catch {
-      return path13.resolve(home);
+      return path14.resolve(home);
     }
   })();
-  return path13.join(resolved, "hooks.json");
+  return path14.join(resolved, "hooks.json");
 }
 var init_codex_home = () => {};
 
@@ -4802,8 +5709,8 @@ function slugifyBranch(branch) {
 var MAX_SLUG_LENGTH = 60;
 
 // packages/daemon/src/git.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 async function git(ws, cwd, args) {
   const run = await ws.exec(["git", ...args], cwd);
   return {
@@ -4820,15 +5727,15 @@ async function gitOrThrow(ws, cwd, args) {
   return result.stdout;
 }
 function canonicalPath(target) {
-  let resolved = path14.resolve(target);
+  let resolved = path15.resolve(target);
   try {
-    resolved = fs14.realpathSync.native(resolved);
+    resolved = fs15.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 ? path14.resolve(result.stdout) : undefined;
+  return result.ok ? path15.resolve(result.stdout) : undefined;
 }
 async function currentBranch(ws, cwd) {
   const result = await git(ws, cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -4837,8 +5744,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 = path14.join(STATE_DIR, "worktrees")) {
-  return path14.join(root, slugifyBranch(path14.basename(repoRoot)), slugifyBranch(branch));
+function worktreePathFor(repoRoot, branch, root = path15.join(STATE_DIR, "worktrees")) {
+  return path15.join(root, slugifyBranch(path15.basename(repoRoot)), slugifyBranch(branch));
 }
 async function createWorktree(ws, options) {
   const { repoRoot, branch, base } = options;
@@ -4846,7 +5753,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 };
-  fs14.mkdirSync(path14.dirname(target), { recursive: true });
+  fs15.mkdirSync(path15.dirname(target), { recursive: true });
   const exists = (await git(ws, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`])).ok;
   const args = exists ? ["worktree", "add", target, branch] : ["worktree", "add", "-b", branch, target, ...base !== undefined ? [base] : []];
   await gitOrThrow(ws, repoRoot, args);
@@ -4899,7 +5806,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, path14.join(worktreePath, file));
+    newLines += await countLines(ws, path15.join(worktreePath, file));
   return {
     filesChanged: a.filesChanged + b.filesChanged + untracked.length,
     insertions: a.insertions + b.insertions + newLines,
@@ -4975,7 +5882,7 @@ var init_injector = __esm(() => {
 
 // packages/daemon/src/occupancy.ts
 import { spawn as spawn3 } from "child_process";
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 function shellOccupied(shellPid) {
   return process.platform === "win32" ? occupiedFromSnapshot(shellPid) : occupiedFromPidProbe(shellPid);
 }
@@ -5020,72 +5927,474 @@ async function occupiedFromSnapshot(shellPid) {
 }
 async function childrenViaProc(pid) {
   try {
-    const children = await fs15.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
+    const children = await fs16.readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
     return children.trim().length > 0;
   } catch {
     try {
-      await fs15.access(`/proc/${pid}`);
+      await fs16.access(`/proc/${pid}`);
       return;
     } catch {
       return false;
     }
-  }
-}
-async function childrenViaPgrep(pid) {
-  const result = await capture("pgrep", ["-P", String(pid)]);
-  if (result === undefined)
-    return;
-  if (result.code === 1)
-    return false;
-  if (result.code !== 0)
+  }
+}
+async function childrenViaPgrep(pid) {
+  const result = await capture("pgrep", ["-P", String(pid)]);
+  if (result === undefined)
+    return;
+  if (result.code === 1)
+    return false;
+  if (result.code !== 0)
+    return;
+  return result.stdout.trim().length > 0;
+}
+async function processTable() {
+  const result = await capture(resolveShell("powershell").exe, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "(Get-CimInstance -ClassName Win32_Process -Property ProcessId,ParentProcessId,Name,CreationDate" + " | Where-Object { $_.Name -ne 'conhost.exe' }" + ` | ForEach-Object { "$($_.ProcessId),$($_.ParentProcessId),$([long]($_.CreationDate.Ticks / 10000))" }) -join ' '`
+  ]);
+  if (result === undefined || result.code !== 0)
+    return;
+  const startedAt = new Map;
+  const newestChild = new Map;
+  for (const row of result.stdout.split(/\s+/)) {
+    const [rawPid, rawParent, rawStarted] = row.split(",");
+    const pid = Number(rawPid);
+    const parent = Number(rawParent);
+    const started = Number(rawStarted);
+    if (!Number.isInteger(pid) || !Number.isInteger(parent) || !Number.isInteger(started))
+      continue;
+    if (pid === result.pid)
+      continue;
+    startedAt.set(pid, started);
+    const newest = newestChild.get(parent);
+    if (newest === undefined || started > newest)
+      newestChild.set(parent, started);
+  }
+  return startedAt.size > 0 ? { startedAt, newestChild } : undefined;
+}
+function capture(exe, argv) {
+  const { promise, resolve } = Promise.withResolvers();
+  const child = spawn3(exe, argv, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  let stdout3 = "";
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    stdout3 += chunk;
+  });
+  child.once("error", () => resolve(undefined));
+  child.once("close", (code) => resolve({ code, stdout: stdout3, pid: child.pid }));
+  return promise;
+}
+var OCCUPANCY_CACHE_MS = 1500, perPid, snapshot;
+var init_occupancy = __esm(() => {
+  init_shell();
+  perPid = new Map;
+});
+
+// packages/daemon/src/agent-store.ts
+import fs17 from "fs";
+import os4 from "os";
+import path16 from "path";
+import { Database as Database3 } from "bun:sqlite";
+function readTailLines(file, maxBytes) {
+  let fd;
+  try {
+    fd = fs17.openSync(file, "r");
+    const size = fs17.fstatSync(fd).size;
+    if (size === 0)
+      return [];
+    const length = Math.min(size, maxBytes);
+    const buffer = Buffer.allocUnsafe(length);
+    fs17.readSync(fd, buffer, 0, length, size - length);
+    const text = buffer.toString("utf8");
+    const lines = text.split(`
+`);
+    if (length < size)
+      lines.shift();
+    if (lines.at(-1) === "")
+      lines.pop();
+    return lines;
+  } catch {
+    return [];
+  } finally {
+    if (fd !== undefined)
+      fs17.closeSync(fd);
+  }
+}
+function claudeConfigDir() {
+  return process.env["CLAUDE_CONFIG_DIR"] ?? path16.join(os4.homedir(), ".claude");
+}
+function codexHome() {
+  return path16.join(STATE_DIR, "codex-home");
+}
+function ompAgentDb() {
+  return path16.join(os4.homedir(), ".omp", "agent", "agent.db");
+}
+function findCodexRollout(sessionId) {
+  const root = path16.join(codexHome(), "sessions");
+  for (const shard2 of codexRolloutShards(sessionId)) {
+    const dir = path16.join(root, ...shard2.split("/"));
+    let entries;
+    try {
+      entries = fs17.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    const match2 = entries.find((name) => name.endsWith(`-${sessionId}.jsonl`));
+    if (match2 !== undefined)
+      return path16.join(dir, match2);
+  }
+  return;
+}
+function newestCodexRollout() {
+  const root = path16.join(codexHome(), "sessions");
+  let best;
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = fs17.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path16.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 3)
+          walk(full, depth + 1);
+        continue;
+      }
+      if (!entry.name.endsWith(".jsonl"))
+        continue;
+      try {
+        const { mtimeMs } = fs17.statSync(full);
+        if (!best || mtimeMs > best.mtimeMs)
+          best = { file: full, mtimeMs };
+      } catch {}
+    }
+  };
+  walk(root, 0);
+  return best?.file;
+}
+function ompQuotaFacts() {
+  const file = ompAgentDb();
+  if (!fs17.existsSync(file))
+    return { agent: "omp", kind: "gauge" };
+  let db;
+  try {
+    db = new Database3(file, { readonly: true, strict: true });
+    const rows = db.query(`SELECT recorded_at, limit_id, label, used_fraction, status, resets_at
+           FROM usage_history
+          WHERE recorded_at = (SELECT MAX(recorded_at) FROM usage_history h WHERE h.limit_id = usage_history.limit_id)
+            AND recorded_at > ?
+          ORDER BY limit_id`).all(Date.now() - 7 * 86400000);
+    const reading = parseOmpQuota(rows);
+    return reading ? { agent: "omp", kind: "gauge", reading } : { agent: "omp", kind: "gauge" };
+  } catch (err) {
+    log(`omp quota unreadable: ${String(err)}`);
+    return { agent: "omp", kind: "gauge" };
+  } finally {
+    db?.close();
+  }
+}
+function codexQuotaFacts() {
+  const file = newestCodexRollout();
+  if (file === undefined)
+    return { agent: "codex", kind: "gauge" };
+  const reading = parseCodexQuota(readTailLines(file, QUOTA_TAIL_BYTES));
+  return reading ? { agent: "codex", kind: "gauge", reading } : { agent: "codex", kind: "gauge" };
+}
+function claudeQuotaFacts(sessions) {
+  const dir = claudeConfigDir();
+  let newest;
+  for (const session of sessions) {
+    if (session.agentSessionId === undefined)
+      continue;
+    const file = path16.join(dir, claudeTranscriptRelPath(session.cwd, session.agentSessionId));
+    const event = parseClaudeLimitEvent(readTailLines(file, QUOTA_TAIL_BYTES));
+    if (event && (!newest || event.at > newest.at))
+      newest = event;
+  }
+  return newest ? { agent: "claude", kind: "event", event: newest } : { agent: "claude", kind: "event" };
+}
+function collectQuotaFacts(agents, sessions, onPath) {
+  const running = new Set(sessions.map((session) => session.agent).filter((agent) => agent !== undefined));
+  const facts = [];
+  for (const agent of agents) {
+    if (!running.has(agent) && onPath(agent) === undefined)
+      continue;
+    const kind = agentProfile(agent).quota;
+    if (kind === undefined) {
+      facts.push({ agent, kind: "none" });
+      continue;
+    }
+    if (agent === "codex")
+      facts.push(codexQuotaFacts());
+    else if (agent === "omp")
+      facts.push(ompQuotaFacts());
+    else if (agent === "claude")
+      facts.push(claudeQuotaFacts(sessions));
+    else
+      facts.push({ agent, kind: kind === "gauge" ? "gauge" : "event" });
+  }
+  return facts;
+}
+function storeQuietForMs(agent, cwd, agentSessionId, nowMs) {
+  if (agentSessionId === undefined)
+    return;
+  const file = agent === "claude" ? path16.join(claudeConfigDir(), claudeTranscriptRelPath(cwd, agentSessionId)) : agent === "codex" ? findCodexRollout(agentSessionId) : undefined;
+  if (file === undefined)
+    return;
+  try {
+    return Math.max(0, nowMs - fs17.statSync(file).mtimeMs);
+  } catch {
+    return;
+  }
+}
+function readFileRange(file, from, to) {
+  if (to <= from)
+    return "";
+  let fd;
+  try {
+    fd = fs17.openSync(file, "r");
+    const buffer = Buffer.allocUnsafe(to - from);
+    const read = fs17.readSync(fd, buffer, 0, to - from, from);
+    return buffer.subarray(0, read).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    if (fd !== undefined)
+      fs17.closeSync(fd);
+  }
+}
+var QUOTA_TAIL_BYTES;
+var init_agent_store = __esm(() => {
+  init_src();
+  init_paths();
+  QUOTA_TAIL_BYTES = 64 * 1024;
+});
+
+// packages/daemon/src/codex-app-server.ts
+import net3 from "net";
+async function freeLoopbackPort() {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const probe = net3.createServer();
+  probe.once("error", reject);
+  probe.listen({ host: "127.0.0.1", port: 0 }, () => {
+    const address = probe.address();
+    const port = typeof address === "object" && address !== null ? address.port : 0;
+    probe.close(() => port > 0 ? resolve(port) : reject(new Error("no port")));
+  });
+  return promise;
+}
+async function waitForPort(port, timeoutMs = READY_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    const open = await new Promise((resolve) => {
+      const socket = net3.connect({ host: "127.0.0.1", port });
+      const done = (value) => {
+        socket.destroy();
+        resolve(value);
+      };
+      socket.once("connect", () => done(true));
+      socket.once("error", () => done(false));
+    });
+    if (open)
+      return true;
+    if (Date.now() >= deadline)
+      return false;
+    await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+  }
+}
+
+class CodexAppServerClient {
+  url;
+  sink;
+  socket;
+  mapper = new CodexStreamMapper;
+  joined = new Set;
+  nextId = 1;
+  closed = false;
+  constructor(url, sink) {
+    this.url = url;
+    this.sink = sink;
+  }
+  get connected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  connect() {
+    if (this.closed)
+      return;
+    let socket;
+    try {
+      socket = new WebSocket(this.url);
+    } catch (err) {
+      log(`codex app-server: cannot connect (${String(err)}); the session keeps its hooks`);
+      return;
+    }
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      this.send("initialize", { clientInfo: { name: "axterm", title: "axterm", version: "1" } });
+    });
+    socket.addEventListener("message", (event) => {
+      this.onFrame(typeof event.data === "string" ? event.data : "");
+    });
+    socket.addEventListener("error", () => {});
+    socket.addEventListener("close", () => {
+      if (!this.closed)
+        log("codex app-server: connection closed; the session keeps its hooks");
+    });
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.socket?.close();
+    } catch {}
+    this.socket = undefined;
+  }
+  send(method, params) {
+    if (this.socket?.readyState !== WebSocket.OPEN)
+      return;
+    this.socket.send(JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, params }));
+  }
+  onFrame(raw) {
+    if (raw === "")
+      return;
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const method = message["method"];
+    if (typeof method !== "string")
+      return;
+    const params = message["params"] ?? {};
+    const threadId = params["threadId"];
+    if (typeof threadId === "string" && !this.joined.has(threadId)) {
+      this.joined.add(threadId);
+      this.send("thread/resume", { threadId });
+      log(`codex app-server: joined thread ${threadId.slice(0, 8)}`);
+    }
+    for (const payload of this.mapper.handle(method, params))
+      this.sink(payload);
+  }
+}
+var READY_TIMEOUT_MS = 1e4, READY_POLL_MS = 100;
+var init_codex_app_server = __esm(() => {
+  init_src();
+  init_paths();
+});
+
+// packages/daemon/src/pty.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import path17 from "path";
+import { StringDecoder } from "string_decoder";
+
+class Fanout {
+  listeners = new Set;
+  backlog = [];
+  add(listener) {
+    this.listeners.add(listener);
+    for (const value of this.backlog)
+      listener(value);
+  }
+  emit(value) {
+    if (this.listeners.size === 0)
+      this.backlog.push(value);
+    else
+      for (const listener of this.listeners)
+        listener(value);
+  }
+}
+function killTree(pid, exeName) {
+  if (process.platform === "win32") {
+    const check = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
+      encoding: "utf8",
+      windowsHide: true
+    });
+    const image = check.stdout?.split(",")[0]?.replace(/"/g, "").toLowerCase() ?? "";
+    if (image === exeName) {
+      spawnSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
+    }
     return;
-  return result.stdout.trim().length > 0;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {}
 }
-async function processTable() {
-  const result = await capture(resolveShell("powershell").exe, [
-    "-NoLogo",
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    "(Get-CimInstance -ClassName Win32_Process -Property ProcessId,ParentProcessId,Name,CreationDate" + " | Where-Object { $_.Name -ne 'conhost.exe' }" + ` | ForEach-Object { "$($_.ProcessId),$($_.ParentProcessId),$([long]($_.CreationDate.Ticks / 10000))" }) -join ' '`
-  ]);
-  if (result === undefined || result.code !== 0)
-    return;
-  const startedAt = new Map;
-  const newestChild = new Map;
-  for (const row of result.stdout.split(/\s+/)) {
-    const [rawPid, rawParent, rawStarted] = row.split(",");
-    const pid = Number(rawPid);
-    const parent = Number(rawParent);
-    const started = Number(rawStarted);
-    if (!Number.isInteger(pid) || !Number.isInteger(parent) || !Number.isInteger(started))
-      continue;
-    if (pid === result.pid)
-      continue;
-    startedAt.set(pid, started);
-    const newest = newestChild.get(parent);
-    if (newest === undefined || started > newest)
-      newestChild.set(parent, started);
+
+class BunPtyHandle {
+  proc;
+  exeName;
+  data = new Fanout;
+  exit = new Fanout;
+  decoder = new StringDecoder("utf8");
+  exited = false;
+  constructor(proc, exeName) {
+    this.proc = proc;
+    this.exeName = exeName;
+  }
+  get pid() {
+    return this.proc.pid;
+  }
+  push(bytes) {
+    const text = this.decoder.write(Buffer.from(bytes));
+    if (text.length > 0)
+      this.data.emit(text);
+  }
+  finish(code) {
+    this.exited = true;
+    const tail = this.decoder.end();
+    if (tail.length > 0)
+      this.data.emit(tail);
+    try {
+      this.proc.terminal.close();
+    } catch {}
+    this.exit.emit(code);
+  }
+  onData(listener) {
+    this.data.add(listener);
+  }
+  onExit(listener) {
+    this.exit.add(listener);
+  }
+  write(data) {
+    this.proc.terminal.write(data);
+  }
+  resize(cols, rows) {
+    this.proc.terminal.resize(cols, rows);
+  }
+  kill() {
+    if (this.exited)
+      return;
+    killTree(this.proc.pid, this.exeName);
+    try {
+      this.proc.kill();
+    } catch {}
   }
-  return startedAt.size > 0 ? { startedAt, newestChild } : undefined;
 }
-function capture(exe, argv) {
-  const { promise, resolve } = Promise.withResolvers();
-  const child = spawn3(exe, argv, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
-  let stdout3 = "";
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    stdout3 += chunk;
+function spawnPty(options) {
+  let handle;
+  const proc = Bun.spawn([options.exe, ...options.argv], {
+    cwd: options.cwd,
+    env: { ...options.env, TERM: options.term },
+    terminal: {
+      cols: options.cols,
+      rows: options.rows,
+      name: options.term,
+      data(_terminal, bytes) {
+        handle?.push(bytes);
+      }
+    }
   });
-  child.once("error", () => resolve(undefined));
-  child.once("close", (code) => resolve({ code, stdout: stdout3, pid: child.pid }));
-  return promise;
+  handle = new BunPtyHandle(proc, path17.basename(options.exe).toLowerCase());
+  proc.exited.then((code) => handle?.finish(code ?? null));
+  return handle;
 }
-var OCCUPANCY_CACHE_MS = 1500, perPid, snapshot;
-var init_occupancy = __esm(() => {
-  init_shell();
-  perPid = new Map;
-});
+var init_pty = () => {};
 
 // node_modules/.bun/@xterm+headless@5.5.0/node_modules/@xterm/headless/lib-headless/xterm-headless.js
 var require_xterm_headless = __commonJS((exports) => {
@@ -9379,154 +10688,46 @@ var require_addon_serialize = __commonJS((exports, module) => {
           this._htmlContent += "<html><body><!--StartFragment--><pre>";
           let r2 = "#000000", o2 = "#ffffff";
           this._options.includeGlobalBackground && (r2 = this._terminal.options.theme?.foreground ?? "#ffffff", o2 = this._terminal.options.theme?.background ?? "#000000");
-          const i2 = [];
-          i2.push("color: " + r2 + ";"), i2.push("background-color: " + o2 + ";"), i2.push("font-family: " + this._terminal.options.fontFamily + ";"), i2.push("font-size: " + this._terminal.options.fontSize + "px;"), this._htmlContent += "<div style='" + i2.join(" ") + "'>";
-        }
-        _afterSerialize() {
-          this._htmlContent += "</div>", this._htmlContent += "</pre><!--EndFragment--></body></html>";
-        }
-        _rowEnd(e3, t4) {
-          this._htmlContent += "<div><span>" + this._currentRow + "</span></div>", this._currentRow = "";
-        }
-        _getHexColor(e3, t4) {
-          const s2 = t4 ? e3.getFgColor() : e3.getBgColor();
-          return (t4 ? e3.isFgRGB() : e3.isBgRGB()) ? "#" + [s2 >> 16 & 255, s2 >> 8 & 255, 255 & s2].map((e4) => this._padStart(e4.toString(16), 2, "0")).join("") : (t4 ? e3.isFgPalette() : e3.isBgPalette()) ? this._ansiColors[s2].css : undefined;
-        }
-        _diffStyle(e3, t4) {
-          const s2 = [], r2 = !n(e3, t4), o2 = !l(e3, t4), i2 = !a(e3, t4);
-          if (r2 || o2 || i2) {
-            const t5 = this._getHexColor(e3, true);
-            t5 && s2.push("color: " + t5 + ";");
-            const r3 = this._getHexColor(e3, false);
-            return r3 && s2.push("background-color: " + r3 + ";"), e3.isInverse() && s2.push("color: #000000; background-color: #BFBFBF;"), e3.isBold() && s2.push("font-weight: bold;"), e3.isUnderline() && e3.isOverline() ? s2.push("text-decoration: overline underline;") : e3.isUnderline() ? s2.push("text-decoration: underline;") : e3.isOverline() && s2.push("text-decoration: overline;"), e3.isBlink() && s2.push("text-decoration: blink;"), e3.isInvisible() && s2.push("visibility: hidden;"), e3.isItalic() && s2.push("font-style: italic;"), e3.isDim() && s2.push("opacity: 0.5;"), e3.isStrikethrough() && s2.push("text-decoration: line-through;"), s2;
-          }
-        }
-        _nextCell(e3, t4, s2, r2) {
-          if (e3.getWidth() === 0)
-            return;
-          const o2 = e3.getChars() === "", i2 = this._diffStyle(e3, t4);
-          i2 && (this._currentRow += i2.length === 0 ? "</span><span>" : "</span><span style='" + i2.join(" ") + "'>"), this._currentRow += o2 ? " " : e3.getChars();
-        }
-        _serializeString() {
-          return this._htmlContent;
-        }
-      }
-      e2.HTMLSerializeHandler = h;
-    })(), r;
-  })());
-});
-
-// packages/daemon/src/pty.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import path15 from "path";
-import { StringDecoder } from "string_decoder";
-
-class Fanout {
-  listeners = new Set;
-  backlog = [];
-  add(listener) {
-    this.listeners.add(listener);
-    for (const value of this.backlog)
-      listener(value);
-  }
-  emit(value) {
-    if (this.listeners.size === 0)
-      this.backlog.push(value);
-    else
-      for (const listener of this.listeners)
-        listener(value);
-  }
-}
-function killTree(pid, exeName) {
-  if (process.platform === "win32") {
-    const check = spawnSync2("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
-      encoding: "utf8",
-      windowsHide: true
-    });
-    const image = check.stdout?.split(",")[0]?.replace(/"/g, "").toLowerCase() ?? "";
-    if (image === exeName) {
-      spawnSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { encoding: "utf8", windowsHide: true });
-    }
-    return;
-  }
-  try {
-    process.kill(-pid, "SIGKILL");
-  } catch {}
-}
-
-class BunPtyHandle {
-  proc;
-  exeName;
-  data = new Fanout;
-  exit = new Fanout;
-  decoder = new StringDecoder("utf8");
-  exited = false;
-  constructor(proc, exeName) {
-    this.proc = proc;
-    this.exeName = exeName;
-  }
-  get pid() {
-    return this.proc.pid;
-  }
-  push(bytes) {
-    const text = this.decoder.write(Buffer.from(bytes));
-    if (text.length > 0)
-      this.data.emit(text);
-  }
-  finish(code) {
-    this.exited = true;
-    const tail = this.decoder.end();
-    if (tail.length > 0)
-      this.data.emit(tail);
-    try {
-      this.proc.terminal.close();
-    } catch {}
-    this.exit.emit(code);
-  }
-  onData(listener) {
-    this.data.add(listener);
-  }
-  onExit(listener) {
-    this.exit.add(listener);
-  }
-  write(data) {
-    this.proc.terminal.write(data);
-  }
-  resize(cols, rows) {
-    this.proc.terminal.resize(cols, rows);
-  }
-  kill() {
-    if (this.exited)
-      return;
-    killTree(this.proc.pid, this.exeName);
-    try {
-      this.proc.kill();
-    } catch {}
-  }
-}
-function spawnPty(options) {
-  let handle;
-  const proc = Bun.spawn([options.exe, ...options.argv], {
-    cwd: options.cwd,
-    env: { ...options.env, TERM: options.term },
-    terminal: {
-      cols: options.cols,
-      rows: options.rows,
-      name: options.term,
-      data(_terminal, bytes) {
-        handle?.push(bytes);
+          const i2 = [];
+          i2.push("color: " + r2 + ";"), i2.push("background-color: " + o2 + ";"), i2.push("font-family: " + this._terminal.options.fontFamily + ";"), i2.push("font-size: " + this._terminal.options.fontSize + "px;"), this._htmlContent += "<div style='" + i2.join(" ") + "'>";
+        }
+        _afterSerialize() {
+          this._htmlContent += "</div>", this._htmlContent += "</pre><!--EndFragment--></body></html>";
+        }
+        _rowEnd(e3, t4) {
+          this._htmlContent += "<div><span>" + this._currentRow + "</span></div>", this._currentRow = "";
+        }
+        _getHexColor(e3, t4) {
+          const s2 = t4 ? e3.getFgColor() : e3.getBgColor();
+          return (t4 ? e3.isFgRGB() : e3.isBgRGB()) ? "#" + [s2 >> 16 & 255, s2 >> 8 & 255, 255 & s2].map((e4) => this._padStart(e4.toString(16), 2, "0")).join("") : (t4 ? e3.isFgPalette() : e3.isBgPalette()) ? this._ansiColors[s2].css : undefined;
+        }
+        _diffStyle(e3, t4) {
+          const s2 = [], r2 = !n(e3, t4), o2 = !l(e3, t4), i2 = !a(e3, t4);
+          if (r2 || o2 || i2) {
+            const t5 = this._getHexColor(e3, true);
+            t5 && s2.push("color: " + t5 + ";");
+            const r3 = this._getHexColor(e3, false);
+            return r3 && s2.push("background-color: " + r3 + ";"), e3.isInverse() && s2.push("color: #000000; background-color: #BFBFBF;"), e3.isBold() && s2.push("font-weight: bold;"), e3.isUnderline() && e3.isOverline() ? s2.push("text-decoration: overline underline;") : e3.isUnderline() ? s2.push("text-decoration: underline;") : e3.isOverline() && s2.push("text-decoration: overline;"), e3.isBlink() && s2.push("text-decoration: blink;"), e3.isInvisible() && s2.push("visibility: hidden;"), e3.isItalic() && s2.push("font-style: italic;"), e3.isDim() && s2.push("opacity: 0.5;"), e3.isStrikethrough() && s2.push("text-decoration: line-through;"), s2;
+          }
+        }
+        _nextCell(e3, t4, s2, r2) {
+          if (e3.getWidth() === 0)
+            return;
+          const o2 = e3.getChars() === "", i2 = this._diffStyle(e3, t4);
+          i2 && (this._currentRow += i2.length === 0 ? "</span><span>" : "</span><span style='" + i2.join(" ") + "'>"), this._currentRow += o2 ? " " : e3.getChars();
+        }
+        _serializeString() {
+          return this._htmlContent;
+        }
       }
-    }
-  });
-  handle = new BunPtyHandle(proc, path15.basename(options.exe).toLowerCase());
-  proc.exited.then((code) => handle?.finish(code ?? null));
-  return handle;
-}
-var init_pty = () => {};
+      e2.HTMLSerializeHandler = h;
+    })(), r;
+  })());
+});
 
 // packages/daemon/src/pty-session.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path18 from "path";
 
 class PtySession {
   info;
@@ -9642,10 +10843,10 @@ class PtySession {
   }
   saveScrollback() {
     try {
-      const file = path16.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
+      const file = path18.join(SCROLLBACK_DIR, `${this.info.id}.bin`);
       const tmp = `${file}.tmp`;
-      fs16.writeFileSync(tmp, this.serializeBuffer(), "utf8");
-      fs16.renameSync(tmp, file);
+      fs18.writeFileSync(tmp, this.serializeBuffer(), "utf8");
+      fs18.renameSync(tmp, file);
     } catch (err) {
       log(`scrollback save failed for ${this.info.shortId}: ${String(err)}`);
     }
@@ -9667,9 +10868,9 @@ var init_pty_session = __esm(() => {
 
 // packages/daemon/src/session-manager.ts
 import { randomBytes as randomBytes2, randomUUID } from "crypto";
-import fs17 from "fs";
+import fs19 from "fs";
 import os5 from "os";
-import path17 from "path";
+import path19 from "path";
 function unresolvableAgent(commandOverride, agentCommand, lookup) {
   if (commandOverride !== undefined)
     return;
@@ -9712,6 +10913,7 @@ async function sendableNow(runtime, info, probe, now) {
 class SessionManager {
   store;
   hooks;
+  configuredDefaults;
   live = new Map;
   agentRuntime = new Map;
   injector = new Injector;
@@ -9719,13 +10921,18 @@ class SessionManager {
   eventListeners = new Set;
   rawHookListeners = new Set;
   workspace = new LocalWorkspace(MATERIALISED_DIR);
-  constructor(store, hooks) {
+  constructor(store, hooks, configuredDefaults = () => ({})) {
     this.store = store;
     this.hooks = hooks;
+    this.configuredDefaults = configuredDefaults;
     const stale = store.markStaleRunningAsExited();
     if (stale > 0)
       log(`boot: marked ${stale} stale session(s) as exited`);
+    this.sessionWatch = setInterval(() => this.tickSessions(), SESSION_TICK_MS);
+    this.sessionWatch.unref();
   }
+  sessionWatch;
+  codexServers = new Map;
   workspaceFor(_sessionId) {
     return this.workspace;
   }
@@ -9802,8 +11009,8 @@ class SessionManager {
     };
   }
   async create(params) {
-    const requestedCwd = params.cwd ? path17.resolve(params.cwd) : os5.homedir();
-    if (!fs17.existsSync(requestedCwd)) {
+    const requestedCwd = params.cwd ? path19.resolve(params.cwd) : os5.homedir();
+    if (!fs19.existsSync(requestedCwd)) {
       throw new AxtermError("err.cwd.missing", { cwd: requestedCwd });
     }
     let worktree;
@@ -9820,17 +11027,29 @@ class SessionManager {
       log(`worktree ${created.createdBranch ? "created" : "reused"} ${created.branch} at ${created.path}`);
     }
     const cwd = worktree?.path ?? requestedCwd;
-    const shell = resolveShell(params.shell);
-    const agent = params.agent ?? "omp";
+    const configured = this.configuredDefaults();
+    const shell = resolveShell(params.shell ?? configured.shell);
+    const agent = params.agent ?? configured.agent ?? "omp";
     if (!isAgentId(agent))
       throw new AxtermError("err.agent.unknown", { agent, supported: supportedAgents().join(", ") });
     const id = randomUUID().replace(/-/g, "");
+    const extraArgs = resolveAgentArgs({
+      bypass: agentProfile(agent).approvalBypassArgs,
+      autoApprove: params.autoApprove,
+      autoApproveConfigured: configured.autoApprove,
+      configured: configured.agentArgs?.[agent],
+      requested: params.agentArgs
+    });
+    const mcpContext = agent === "omp" ? undefined : this.mcpContextPath(id);
+    const mcpConfigPath = agent === "claude" ? this.writeMcpConfig(id, mcpContext) : undefined;
     const agentCommand = params.commandOverride ?? buildAgentCommand({
       agent,
       sessionId: id,
       extensionPath: this.hooks.extensionPath,
       claudeSettingsPath: this.claudeSettingsPath(id),
-      ...params.agentArgs !== undefined ? { extraArgs: params.agentArgs } : {}
+      ...mcpConfigPath === undefined ? {} : { mcpConfigPath },
+      ...agent === "codex" ? { mcpLaunch: this.mcpServerLaunch(), mcpContextPath: mcpContext } : {},
+      ...extraArgs.length > 0 ? { extraArgs } : {}
     });
     const missing = unresolvableAgent(params.commandOverride, agentCommand, lookupOnPath);
     if (missing !== undefined)
@@ -9838,7 +11057,7 @@ class SessionManager {
     const info = {
       id,
       shortId: id.slice(0, 6),
-      name: params.name ?? worktree?.branch ?? path17.basename(cwd),
+      name: params.name ?? worktree?.branch ?? path19.basename(cwd),
       cwd,
       shell: shell.kind,
       agentCommand,
@@ -9848,7 +11067,8 @@ class SessionManager {
       createdAt: Date.now(),
       ...worktree !== undefined ? { worktreePath: worktree.path, branch: worktree.branch, repoRoot: worktree.repoRoot } : {}
     };
-    this.launch(info, shell, agentCommand);
+    const appServerUrl = agent === "codex" ? await this.startCodexAppServer(id, this.ensureCodexHome(), cwd) : undefined;
+    this.launch(info, shell, agentCommand, appServerUrl);
     this.store.insertSession(info);
     log(`session ${info.shortId} created shell=${shell.kind} cmd=${agentCommand.join(" ") || "(shell only)"}`);
     this.emit({ t: "session.created", info });
@@ -9862,37 +11082,82 @@ class SessionManager {
       launchToken
     });
     const file = this.claudeSettingsPath(id);
-    fs17.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
+    fs19.writeFileSync(file, JSON.stringify(settings, null, 2), { mode: 384 });
   }
-  writeGeminiSettings() {
+  writeGeminiSettings(sessionId) {
     try {
       const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "gemini" });
-      const settings = buildGeminiSettings({ command: bridge.command, args: bridge.args });
+      const settings = buildGeminiSettings({
+        command: bridge.command,
+        args: bridge.args,
+        mcp: this.mcpServerLaunch(),
+        mcpContextPath: this.mcpContextPath(sessionId)
+      });
       const file = this.geminiSettingsPath();
       const tmp = `${file}.tmp`;
-      fs17.writeFileSync(tmp, JSON.stringify(settings, null, 2));
-      fs17.renameSync(tmp, file);
+      fs19.writeFileSync(tmp, JSON.stringify(settings, null, 2));
+      fs19.renameSync(tmp, file);
     } catch (err) {
       log(`gemini settings write failed; session starts without hooks: ${String(err)}`);
     }
   }
+  async startCodexAppServer(id, codexHome2, cwd) {
+    try {
+      const port = await freeLoopbackPort();
+      const url = `ws://127.0.0.1:${port}`;
+      const proc = Bun.spawn(["codex", "app-server", "--listen", url], {
+        cwd,
+        env: { ...stripHostAttribution(process.env), CODEX_HOME: codexHome2 },
+        stdout: "ignore",
+        stderr: "ignore",
+        stdin: "ignore"
+      });
+      if (!await waitForPort(port)) {
+        proc.kill();
+        log(`codex app-server did not open ${port}; session ${id.slice(0, 6)} keeps its hooks`);
+        return;
+      }
+      const client = new CodexAppServerClient(url, (payload) => this.ingestHookEvent(id, payload));
+      client.connect();
+      this.codexServers.set(id, {
+        stop: () => {
+          client.close();
+          try {
+            killTree(proc.pid, "codex.exe");
+          } catch {}
+          try {
+            proc.kill();
+          } catch {}
+        }
+      });
+      log(`codex app-server on ${url} for session ${id.slice(0, 6)} in ${cwd}`);
+      return url;
+    } catch (err) {
+      log(`codex app-server unavailable (${String(err)}); session ${id.slice(0, 6)} keeps its hooks`);
+      return;
+    }
+  }
+  stopCodexAppServer(id) {
+    this.codexServers.get(id)?.stop();
+    this.codexServers.delete(id);
+  }
   ensureCodexHome() {
-    const home = path17.join(STATE_DIR, "codex-home");
-    fs17.mkdirSync(home, { recursive: true, mode: 448 });
+    const home = path19.join(STATE_DIR, "codex-home");
+    fs19.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`;
-    fs17.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
-    fs17.renameSync(tmp, hooksPath);
+    fs19.writeFileSync(tmp, JSON.stringify(hooksFile, null, 2));
+    fs19.renameSync(tmp, hooksPath);
     const entries = codexHookTrust(hooksPath, hooksFile);
-    const configPath = path17.join(home, "config.toml");
-    const existing = fs17.existsSync(configPath) ? fs17.readFileSync(configPath, "utf8") : "";
+    const configPath = path19.join(home, "config.toml");
+    const existing = fs19.existsSync(configPath) ? fs19.readFileSync(configPath, "utf8") : "";
     const missing = entries.filter((e) => !existing.includes(`"${e.key.replaceAll("\\", "\\\\")}"`));
     if (missing.length > 0) {
       const block = codexTrustStateToml(missing);
-      fs17.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
+      fs19.appendFileSync(configPath, existing !== "" && !existing.endsWith(`
 `) ? `
 ${block}` : block);
     }
@@ -9905,18 +11170,18 @@ ${block}` : block);
     return home;
   }
   linkCodexAuth(home) {
-    const target = path17.join(home, "auth.json");
-    if (fs17.existsSync(target))
+    const target = path19.join(home, "auth.json");
+    if (fs19.existsSync(target))
       return;
-    const operatorHome = process.env["CODEX_HOME"] ?? path17.join(os5.homedir(), ".codex");
-    const source = path17.join(operatorHome, "auth.json");
-    if (!fs17.existsSync(source))
+    const operatorHome = process.env["CODEX_HOME"] ?? path19.join(os5.homedir(), ".codex");
+    const source = path19.join(operatorHome, "auth.json");
+    if (!fs19.existsSync(source))
       throw new AxtermError("err.codex.noAuth", { authFile: source });
     try {
-      fs17.symlinkSync(source, target, "file");
+      fs19.symlinkSync(source, target, "file");
     } catch {
       try {
-        fs17.linkSync(source, target);
+        fs19.linkSync(source, target);
       } catch (err) {
         throw new AxtermError("err.codex.authLink", { reason: err instanceof Error ? err.message : String(err) });
       }
@@ -9924,37 +11189,45 @@ ${block}` : block);
   }
   doctorReport() {
     const bridge = hookLaunch({ execPath: process.execPath, mainScript: Bun.main, agent: "codex" });
-    const home = path17.join(STATE_DIR, "codex-home");
-    const operatorHome = process.env["CODEX_HOME"] ?? path17.join(os5.homedir(), ".codex");
-    const authSource = path17.join(operatorHome, "auth.json");
+    const home = path19.join(STATE_DIR, "codex-home");
+    const operatorHome = process.env["CODEX_HOME"] ?? path19.join(os5.homedir(), ".codex");
+    const authSource = path19.join(operatorHome, "auth.json");
     const geminiSettings = this.geminiSettingsPath();
-    const configPath = path17.join(home, "config.toml");
+    const configPath = path19.join(home, "config.toml");
     const read = (file) => {
       try {
-        return fs17.existsSync(file) ? fs17.readFileSync(file, "utf8") : undefined;
+        return fs19.existsSync(file) ? fs19.readFileSync(file, "utf8") : undefined;
       } catch {
         return;
       }
     };
     return [
-      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs17.existsSync(bridge.command) }),
+      ...evaluateBridgeDoctor({ command: bridge.command, exists: fs19.existsSync(bridge.command) }),
       ...evaluateOmpDoctor({
         binary: lookupOnPath("omp"),
         extensionPath: this.hooks.extensionPath,
-        extensionExists: fs17.existsSync(this.hooks.extensionPath)
+        extensionExists: fs19.existsSync(this.hooks.extensionPath)
       }),
       ...evaluateClaudeDoctor({ binary: lookupOnPath("claude") }),
       ...evaluateCodexDoctor({
         binary: lookupOnPath("codex"),
         authSourcePath: authSource,
-        authSourceExists: fs17.existsSync(authSource),
-        homeExists: fs17.existsSync(home),
+        authSourceExists: fs19.existsSync(authSource),
+        homeExists: fs19.existsSync(home),
         expected: codexHookTrust(codexTrustKeyPath(home), buildCodexHooks({ command: bridge.command, args: bridge.args })),
         configToml: read(configPath)
       }),
       ...evaluateGeminiDoctor({ binary: lookupOnPath("gemini"), settingsJson: read(geminiSettings) })
     ];
   }
+  quotaReport() {
+    const sessions = this.store.listSessions().map((session) => ({
+      cwd: session.cwd,
+      agent: agentIdFromCommand(session.agentCommand),
+      ...session.agentSessionId === undefined ? {} : { agentSessionId: session.agentSessionId }
+    }));
+    return quotaReport(collectQuotaFacts(REGISTERED_AGENTS, sessions, lookupOnPath), Date.now());
+  }
   sawOutput = new Set;
   idleTimers = new Map;
   lastCaptured = new Map;
@@ -9981,7 +11254,7 @@ ${block}` : block);
     if (!session || !runtime)
       return;
     const found = detectPrompt(session.screenText(4));
-    const dialog = found === undefined && agentIdFromCommand(session.info.agentCommand) === "gemini" ? detectGeminiOnboarding(session.screenText(30)) : undefined;
+    const dialog = found === undefined ? detectOnboarding(agentIdFromCommand(session.info.agentCommand), session.screenText(30)) : undefined;
     if (!found && !dialog) {
       if (this.pendingPrompt.delete(id))
         this.emit({ t: "choice.resolved", sessionId: id, seq: runtime.choiceSeq });
@@ -10064,51 +11337,89 @@ ${block}` : block);
   }
   writeScreenFile(idOrPrefix, lines) {
     const session = this.resolveLive(idOrPrefix);
-    const file = path17.join(path17.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
-    fs17.writeFileSync(file, session.screenText(lines), { mode: 384 });
+    const file = path19.join(path19.dirname(this.hooks.endpointFile), `screen-${session.info.id}.txt`);
+    fs19.writeFileSync(file, session.screenText(lines), { mode: 384 });
     return file;
   }
   removeScreenFile(id) {
     try {
-      fs17.rmSync(path17.join(path17.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
+      fs19.rmSync(path19.join(path19.dirname(this.hooks.endpointFile), `screen-${id}.txt`), { force: true });
     } catch {}
   }
   async stageInboundFile(idOrPrefix, suggestedName, bytes) {
     const info = this.resolveLive(idOrPrefix).info;
-    const file = path17.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
-    await fs17.promises.mkdir(path17.dirname(file), { recursive: true, mode: 448 });
-    await fs17.promises.writeFile(file, bytes, { mode: 384 });
-    log(`session ${info.shortId} staged ${path17.basename(file)} (${bytes.byteLength} bytes)`);
+    const file = path19.resolve(planMaterialisedPath(MATERIALISED_DIR, info.id, suggestedName));
+    await fs19.promises.mkdir(path19.dirname(file), { recursive: true, mode: 448 });
+    await fs19.promises.writeFile(file, bytes, { mode: 384 });
+    log(`session ${info.shortId} staged ${path19.basename(file)} (${bytes.byteLength} bytes)`);
     return file;
   }
   removeStagedFiles(id) {
     try {
-      fs17.rmSync(path17.join(MATERIALISED_DIR, id), { recursive: true, force: true });
+      fs19.rmSync(path19.join(MATERIALISED_DIR, id), { recursive: true, force: true });
     } catch {}
   }
   removeClaudeSettings(id) {
     try {
-      fs17.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs19.rmSync(this.claudeSettingsPath(id), { force: true });
+      fs19.rmSync(this.mcpConfigPath(id), { force: true });
+      fs19.rmSync(this.mcpContextPath(id), { force: true });
+      fs19.rmSync(this.geminiTelemetryPath(id), { force: true });
+      this.stopCodexAppServer(id);
     } catch {}
   }
   claudeSettingsPath(id) {
-    return path17.join(path17.dirname(this.hooks.endpointFile), `claude-${id}.json`);
+    return path19.join(path19.dirname(this.hooks.endpointFile), `claude-${id}.json`);
+  }
+  mcpConfigPath(id) {
+    return path19.join(path19.dirname(this.hooks.endpointFile), `mcp-${id}.json`);
+  }
+  mcpContextPath(id) {
+    return path19.join(path19.dirname(this.hooks.endpointFile), `mcp-ctx-${id}.json`);
+  }
+  writeMcpContext(id, launchToken) {
+    const file = this.mcpContextPath(id);
+    try {
+      fs19.writeFileSync(file, JSON.stringify({ port: this.hooks.port, token: this.hooks.host.token, sessionId: id, launchToken }), { mode: 384 });
+      return file;
+    } catch (err) {
+      log(`mcp context write failed; session starts without axterm's tools: ${String(err)}`);
+      return;
+    }
+  }
+  mcpServerLaunch() {
+    return mcpLaunch({ execPath: process.execPath, mainScript: Bun.main });
+  }
+  writeMcpConfig(id, contextPath) {
+    const file = this.mcpConfigPath(id);
+    try {
+      fs19.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)}`);
+      return;
+    }
+  }
+  geminiTelemetryPath(id) {
+    return path19.join(path19.dirname(this.hooks.endpointFile), `gemini-telemetry-${id}.log`);
   }
   geminiSettingsPath() {
-    return path17.join(path17.dirname(this.hooks.endpointFile), "gemini-defaults.json");
+    return path19.join(path19.dirname(this.hooks.endpointFile), "gemini-defaults.json");
   }
-  launch(info, shell, agentCommand) {
+  launch(info, shell, agentCommand, appServerUrl) {
     const id = info.id;
     const launchToken = randomBytes2(16).toString("hex");
     const agentId = agentIdFromCommand(info.agentCommand);
     if (agentId === "claude")
       this.writeClaudeSettings(id, launchToken);
+    if (agentId !== "omp")
+      this.writeMcpContext(id, launchToken);
     if (agentId === "gemini")
-      this.writeGeminiSettings();
-    const codexHome = agentId === "codex" ? this.ensureCodexHome() : undefined;
+      this.writeGeminiSettings(id);
+    const codexHome2 = agentId === "codex" ? this.ensureCodexHome() : undefined;
     const session = new PtySession(info, {
       exe: shell.exe,
-      argv: buildShellArgv(shell, agentCommand),
+      argv: buildShellArgv(shell, withAppServer(agentCommand, appServerUrl)),
       cwd: info.cwd,
       cols: info.cols,
       rows: info.rows,
@@ -10119,8 +11430,15 @@ ${block}` : block);
         AXTERM_HOOK_PORT: String(this.hooks.port),
         AXTERM_HOOK_TOKEN: this.hooks.host.token,
         AXTERM_HOOK_ENDPOINT: this.hooks.endpointFile,
-        ...agentId === "gemini" ? { GEMINI_CLI_SYSTEM_DEFAULTS_PATH: this.geminiSettingsPath() } : {},
-        ...codexHome !== undefined ? { CODEX_HOME: codexHome } : {}
+        ...agentId === "gemini" ? {
+          GEMINI_CLI_SYSTEM_DEFAULTS_PATH: this.geminiSettingsPath(),
+          GEMINI_TELEMETRY_ENABLED: "true",
+          GEMINI_TELEMETRY_TARGET: "local",
+          GEMINI_TELEMETRY_OUTFILE: this.geminiTelemetryPath(id),
+          GEMINI_TELEMETRY_LOG_PROMPTS: "false",
+          GEMINI_TELEMETRY_TRACES_ENABLED: "false"
+        } : {},
+        ...codexHome2 !== undefined ? { CODEX_HOME: codexHome2 } : {}
       }
     });
     this.agentRuntime.set(id, { agentExited: false, choiceSeq: 0, dialogOpen: false });
@@ -10242,6 +11560,9 @@ ${block}` : block);
       this.emit({ t: "chat.message", sessionId: id, role: "assistant", text: result.assistantText });
     }
     if (payload.event === "before_agent_start") {
+      const runtime2 = this.agentRuntime.get(id);
+      if (runtime2 !== undefined)
+        runtime2.telemetryReported = false;
       const prompt = (payload.prompt ?? "").trim();
       if (prompt.length > 0 && !this.echoGuard.consume(id, prompt, now)) {
         this.emit({ t: "chat.message", sessionId: id, role: "user", text: prompt });
@@ -10318,14 +11639,10 @@ ${block}` : block);
     return this.allSessions();
   }
   allSessions() {
-    const liveIds = new Set(this.live.keys());
-    return [
-      ...[...this.live.values()].map((s) => s.info),
-      ...this.store.listSessions().filter((s) => !liveIds.has(s.id))
-    ];
+    return sessionsByRecency([...this.live.values()].map((s) => s.info), this.store.listSessions());
   }
   resumeNamed(stored, agent) {
-    if (!fs17.existsSync(stored.cwd))
+    if (!fs19.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const agentCommand = buildAgentResumeCommand({
       agent,
@@ -10344,7 +11661,7 @@ ${block}` : block);
     this.emit({ t: "session.created", info });
     return info;
   }
-  resume(idOrPrefix) {
+  async resume(idOrPrefix) {
     const stored = this.store.findByPrefix(idOrPrefix);
     if (!stored)
       throw new AxtermError("err.session.unknown", { id: idOrPrefix });
@@ -10365,7 +11682,7 @@ ${block}` : block);
     if (agentCommand === undefined) {
       throw new AxtermError("err.session.noResumeSupport", { agent: profile.displayName });
     }
-    if (!fs17.existsSync(stored.cwd))
+    if (!fs19.existsSync(stored.cwd))
       throw new AxtermError("err.session.cwdGone", { cwd: stored.cwd });
     const info = { ...stored, agentCommand, state: "running" };
     delete info.exitCode;
@@ -10373,7 +11690,8 @@ ${block}` : block);
     delete info.agentState;
     delete info.agentStateSource;
     const shell = resolveShell(info.shell);
-    this.launch(info, shell, agentCommand);
+    const resumedAppServer = agentIdFromCommand(agentCommand) === "codex" ? await this.startCodexAppServer(info.id, this.ensureCodexHome(), info.cwd) : undefined;
+    this.launch(info, shell, agentCommand, resumedAppServer);
     this.store.markResumed(info.id, agentCommand, info.ptyPid);
     log(`session ${info.shortId} resumed cmd=${agentCommand.join(" ")}`);
     this.emit({ t: "session.created", info });
@@ -10438,11 +11756,86 @@ ${block}` : block);
   removeScrollback(id) {
     for (const file of [`${id}.bin`, `${id}.bin.tmp`]) {
       try {
-        fs17.rmSync(path17.join(SCROLLBACK_DIR, file), { force: true });
+        fs19.rmSync(path19.join(SCROLLBACK_DIR, file), { force: true });
       } catch {}
     }
   }
+  tickSessions() {
+    this.drainGeminiTelemetry();
+    this.watchForStalls();
+  }
+  drainGeminiTelemetry() {
+    for (const [id, session] of this.live) {
+      if (agentIdFromCommand(session.info.agentCommand) !== "gemini")
+        continue;
+      const runtime = this.agentRuntime.get(id);
+      if (runtime === undefined)
+        continue;
+      const file = this.geminiTelemetryPath(id);
+      let size = 0;
+      try {
+        size = fs19.statSync(file).size;
+      } catch {
+        continue;
+      }
+      const offset = runtime.telemetryOffset ?? 0;
+      const from = size < offset ? 0 : offset;
+      if (size < offset)
+        runtime.telemetryRemainder = "";
+      if (size <= from)
+        continue;
+      const chunk = readFileRange(file, from, size);
+      runtime.telemetryOffset = size;
+      const split = splitTelemetryRecords(`${runtime.telemetryRemainder ?? ""}${chunk}`);
+      runtime.telemetryRemainder = split.remainder;
+      const failures = parseGeminiTelemetry(split.complete);
+      if (failures.length === 0)
+        continue;
+      const first = failures[0];
+      log(`session ${session.info.shortId} gemini api failure${first.status === undefined ? "" : ` (${first.status})`}: ${first.text.slice(0, 200)}`);
+      if (runtime.telemetryReported === true)
+        continue;
+      runtime.telemetryReported = true;
+      this.emit({
+        t: "agent.error",
+        sessionId: id,
+        kind: "attempt",
+        text: first.status === undefined ? first.text : `${first.status} ${first.text}`
+      });
+    }
+  }
+  watchForStalls() {
+    const now = Date.now();
+    for (const [id, session] of this.live) {
+      const runtime = this.agentRuntime.get(id);
+      if (runtime === undefined)
+        continue;
+      const quietForMs = now - session.lastOutputAt;
+      if (quietForMs <= STALL_AFTER_MS) {
+        runtime.stallReported = false;
+        continue;
+      }
+      const storeQuiet = storeQuietForMs(agentIdFromCommand(session.info.agentCommand), session.info.cwd, session.info.agentSessionId, now);
+      if (!shouldReportStall({
+        agentState: runtime.entry?.state,
+        quietForMs,
+        thresholdMs: STALL_AFTER_MS,
+        reported: runtime.stallReported === true,
+        ...storeQuiet === undefined ? {} : { storeQuietForMs: storeQuiet }
+      })) {
+        continue;
+      }
+      runtime.stallReported = true;
+      const screen = quoteScreenTail(session.screenText(STALL_SCREEN_LINES), STALL_QUOTE_LINES).join(`
+`);
+      log(`session ${session.info.shortId} has made no progress for ${Math.round(quietForMs / 1000)}s`);
+      this.emit({ t: "agent.error", sessionId: id, kind: "stalled", text: screen, retryMs: quietForMs });
+    }
+  }
   shutdownAll() {
+    clearInterval(this.sessionWatch);
+    for (const id of [...this.codexServers.keys()])
+      this.stopCodexAppServer(id);
     for (const session of this.live.values()) {
       session.saveScrollback();
       session.kill();
@@ -10451,7 +11844,7 @@ ${block}` : block);
     this.agentRuntime.clear();
   }
 }
-var DEFAULT_COLS = 120, DEFAULT_ROWS = 30, MATERIALISED_DIR, ACTIVITY_ARG_CHARS = 160, PROMPT_SETTLE_MS = 400, PROMPT_OPTIONS, AGENT_EXIT_CONFIRM_MS = 5000;
+var DEFAULT_COLS = 120, DEFAULT_ROWS = 30, MATERIALISED_DIR, ACTIVITY_ARG_CHARS = 160, PROMPT_SETTLE_MS = 400, STALL_AFTER_MS = 180000, STALL_SCREEN_LINES = 24, STALL_QUOTE_LINES = 6, SESSION_TICK_MS = 5000, PROMPT_OPTIONS, AGENT_EXIT_CONFIRM_MS = 5000;
 var init_session_manager = __esm(() => {
   init_src();
   init_codex_home();
@@ -10459,11 +11852,14 @@ var init_session_manager = __esm(() => {
   init_git();
   init_injector();
   init_occupancy();
+  init_agent_store();
+  init_codex_app_server();
+  init_pty();
   init_paths();
   init_pty_session();
   init_shell();
   init_workspace_local();
-  MATERIALISED_DIR = path17.join(RUNTIME_DIR, "materialised");
+  MATERIALISED_DIR = path19.join(RUNTIME_DIR, "materialised");
   PROMPT_OPTIONS = {
     hostKey: [{ label: "yes" }, { label: "no" }],
     password: [],
@@ -10612,11 +12008,11 @@ var init_acknowledge = __esm(() => {
 });
 
 // packages/channel-telegram/src/attach.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path20 from "path";
 function buildAttachmentUpload(filePath, chatId, topicId, caption, limits = TELEGRAM_LIMITS) {
-  const name = path18.basename(filePath);
-  const bytes = fs18.statSync(filePath).size;
+  const name = path20.basename(filePath);
+  const bytes = fs20.statSync(filePath).size;
   const plan = planAttachment({ name, bytes }, limits);
   if (plan.kind === "rejected")
     throw new Error(plan.reason);
@@ -10626,7 +12022,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([fs18.readFileSync(filePath)]), name);
+  form.append(field, new Blob([fs20.readFileSync(filePath)]), name);
   return { method: plan.kind === "photo" ? "sendPhoto" : "sendDocument", field, form };
 }
 function isPhotoRejection(error) {
@@ -10634,13 +12030,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 = path18.basename(filePath);
+  const name = path20.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([fs18.readFileSync(filePath)]), name);
+  form.append("document", new Blob([fs20.readFileSync(filePath)]), name);
   return { method: "sendDocument", field: "document", form };
 }
 var TELEGRAM_LIMITS;
@@ -11407,6 +12803,14 @@ class TelegramChannel {
       await this.sendToSession(sessionId, message);
     }
   }
+  quotaText() {
+    const checks = this.control.quota();
+    if (checks.length === 0)
+      return escapeHtml(t("cli.quota.none"));
+    const GLYPHS = { ok: "\uD83D\uDFE2", info: "\u26AA", warn: "\uD83D\uDD34", fail: "\uD83D\uDD34" };
+    return checks.map((check) => `${GLYPHS[check.status]} ${escapeHtml(t(check.key, check.params ?? {}))}`).join(`
+`);
+  }
   async onAgentStatus(sessionId, state, toolName) {
     const binding = this.control.findBindingBySession(sessionId);
     if (!binding)
@@ -11527,7 +12931,7 @@ ${code(prompt.line)}`,
     });
   }
   awaitingSecret = new Map;
-  async onChoiceRequest(sessionId, seq, questions, askId, onboarding = false) {
+  async onChoiceRequest(sessionId, seq, questions, askId, onboarding2 = false) {
     const binding = this.control.findBindingBySession(sessionId);
     if (!binding || questions.length === 0)
       return;
@@ -11544,7 +12948,7 @@ ${code(prompt.line)}`,
       answers: [],
       picked: [],
       ...askId !== undefined ? { askId } : {},
-      ...onboarding ? { onboarding: true } : {}
+      ...onboarding2 ? { onboarding: true } : {}
     });
     await this.renderChoiceStep(sessionId);
   }
@@ -11609,7 +13013,7 @@ ${code(prompt.line)}`,
   }
   async onAgentError(sessionId, kind, text, retryMs) {
     const reason = clipText(text, AGENT_ERROR_CHARS);
-    const message = kind === "retry" && retryMs !== undefined && retryMs > 0 ? tHtml("tg.agent.retry", { wait: humanDuration(retryMs), error: reason }) : tHtml("tg.agent.failed", { error: reason });
+    const message = kind === "stalled" ? tHtml("tg.agent.stalled", { wait: humanDuration(retryMs ?? 0), screen: reason }) : kind === "attempt" ? tHtml("tg.agent.attempt", { error: reason }) : kind === "retry" && retryMs !== undefined && retryMs > 0 ? tHtml("tg.agent.retry", { wait: humanDuration(retryMs), error: reason }) : tHtml("tg.agent.failed", { error: reason });
     await this.sendToSession(sessionId, message);
   }
   async onChatMessage(sessionId, role, text) {
@@ -11773,8 +13177,8 @@ ${code(prompt.line)}`,
         throw new Error("this Telegram client cannot download files");
       const files = [];
       for (const item of batch.items) {
-        const path19 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
-        files.push({ path: path19, kind: item.kind });
+        const path21 = await this.control.stageInboundFile(batch.sessionId, item.name, await download2(item.fileId));
+        files.push({ path: path21, kind: item.kind });
       }
       await this.control.prompt(batch.sessionId, buildAttachmentPrompt(files, batch.caption));
       this.log(`staged ${files.length} inbound file(s) for ${batch.sessionId}`);
@@ -11800,6 +13204,7 @@ ${code(prompt.line)}`,
   }
   async handleCommand(text, binding, msg) {
     const [rawCmd = "", ...args] = text.split(/\s+/);
+    const rawTail = text.slice(rawCmd.length);
     const cmd = rawCmd.replace(/@\w+$/, "");
     if (binding) {
       switch (cmd) {
@@ -11809,9 +13214,34 @@ ${code(prompt.line)}`,
         case "/kill":
           this.control.kill(binding.sessionId);
           return;
+        case "/key": {
+          const parsed = parseKeyNames(args.join(" "));
+          if ("unknown" in parsed) {
+            await this.sendToSession(binding.sessionId, tHtml("tg.raw.unknownKey", { name: parsed.unknown, keys: KEY_NAMES.join(" ") }));
+            return;
+          }
+          for (const sequence of parsed.keys)
+            this.control.write(binding.sessionId, sequence);
+          await this.sendToSession(binding.sessionId, tHtml("tg.raw.keysSent", { keys: args.join(" ") }));
+          return;
+        }
+        case "/type": {
+          const typed = rawTail.replace(/^ /, "");
+          if (typed === "") {
+            await this.sendToSession(binding.sessionId, tHtml("tg.raw.needText"));
+            return;
+          }
+          if (typed.length > RAW_TYPE_LIMIT) {
+            await this.sendToSession(binding.sessionId, tHtml("tg.raw.tooLong", { limit: RAW_TYPE_LIMIT }));
+            return;
+          }
+          this.control.write(binding.sessionId, typed);
+          await this.sendToSession(binding.sessionId, tHtml("tg.raw.typed", { screen: this.control.screen(binding.sessionId, RAW_SCREEN_LINES) }));
+          return;
+        }
         case "/resume": {
           try {
-            const info = this.control.resume(binding.sessionId);
+            const info = await this.control.resume(binding.sessionId);
             await this.sendToSession(binding.sessionId, tHtml("tg.resume.done", { command: info.agentCommand.join(" ") }));
           } catch (err) {
             await this.sendToSession(binding.sessionId, tHtml("tg.resume.failed", { error: localizeError(err) }));
@@ -11826,6 +13256,10 @@ ${code(prompt.line)}`,
         case "/diff":
           await this.postDiffSummary(binding.sessionId);
           return;
+        case "/quota": {
+          await this.sendToSession(binding.sessionId, this.quotaText());
+          return;
+        }
         default:
           await this.sendToSession(binding.sessionId, helpText());
           return;
@@ -12024,8 +13458,8 @@ ${code(prompt.line)}`,
       return;
     }
     if (flow.askId === undefined) {
-      const keys = agentProfile(agentIdFromCommand(session.agentCommand)).approvalKeys;
-      this.control.write(session.id, keys !== undefined && decoded.optionIndex <= 1 ? decoded.optionIndex === 0 ? keys.allow : keys.deny : buildMenuSelectKeys(decoded.optionIndex));
+      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));
     }
     flow.answers.push({ questionIndex: flow.cursor, selected: [label] });
     flow.cursor += 1;
@@ -12103,7 +13537,7 @@ ${code(prompt.line)}`,
     }
   }
 }
-var SCREEN_MESSAGE_BUDGET = 2, AGENT_ERROR_CHARS = 1200, HELP_KEYS, helpText = () => HELP_KEYS.map((key) => escapeHtml(t(key))).join(`
+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`;
 var init_adapter = __esm(() => {
   init_src();
@@ -12170,6 +13604,7 @@ class TelegramService {
     return {
       ...telegram?.botToken !== undefined ? { botToken: telegram.botToken } : {},
       ...telegram?.groupId !== undefined ? { groupId: telegram.groupId } : {},
+      ...telegram?.enabled !== undefined ? { enabled: telegram.enabled } : {},
       ...telegram?.allowUserIds?.[0] !== undefined ? { allowUserId: telegram.allowUserIds[0] } : {},
       ...machine2 !== undefined ? { machine: machine2 } : {}
     };
@@ -12204,13 +13639,27 @@ class TelegramService {
       hasToken: s.botToken !== undefined
     };
   }
+  async discover(botToken) {
+    if (this.channel !== undefined)
+      throw new AxtermError("err.telegram.discoverWhileRunning");
+    const token = botToken ?? this.readSettings().botToken;
+    if (!token)
+      throw new AxtermError("err.telegram.noToken");
+    const api = new FetchTelegramApi(token);
+    const updates = await api.call("getUpdates", { timeout: 0 });
+    return discoverTelegramTargets(updates);
+  }
   start() {
     const s = this.readSettings();
+    this.stop();
+    if (s.enabled === false) {
+      log("telegram: disabled by configuration, channel not started");
+      return false;
+    }
     if (!s.botToken || s.groupId === undefined || s.allowUserId === undefined) {
       log("telegram: not configured, channel not started");
       return false;
     }
-    this.stop();
     const api = new FetchTelegramApi(s.botToken);
     const config = {
       groupId: s.groupId,
@@ -12252,6 +13701,7 @@ class TelegramService {
       answerShellPrompt: (id, seq, text) => this.manager.answerShellPrompt(id, seq, text),
       answerOnboarding: (id, seq, optionIndex) => this.manager.answerOnboardingChoice(id, seq, optionIndex),
       diff: (id) => this.manager.sessionDiff(id),
+      quota: () => this.manager.quotaReport(),
       saveBinding: (b) => this.store.saveBinding(b),
       findBindingBySession: (id) => this.store.findBindingBySession(id),
       findBindingByTopic: (chatId, topicId) => this.store.findBindingByTopic(chatId, topicId),
@@ -12358,8 +13808,8 @@ var init_telegram_service = __esm(() => {
 // packages/daemon/src/index.ts
 var exports_src = {};
 import { randomBytes as randomBytes3 } from "crypto";
-import fs19 from "fs";
-import net3 from "net";
+import fs21 from "fs";
+import net4 from "net";
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -12370,9 +13820,9 @@ function isPidAlive(pid) {
 }
 async function main() {
   ensureDataDirs();
-  if (fs19.existsSync(RUNTIME_FILE2)) {
+  if (fs21.existsSync(RUNTIME_FILE2)) {
     try {
-      const existing = JSON.parse(fs19.readFileSync(RUNTIME_FILE2, "utf8"));
+      const existing = JSON.parse(fs21.readFileSync(RUNTIME_FILE2, "utf8"));
       if (existing.pid !== process.pid && isPidAlive(existing.pid)) {
         log(`daemon already running (pid ${existing.pid}); exiting`);
         process.exit(0);
@@ -12395,7 +13845,7 @@ async function main() {
     version: productVersion(),
     startedAt: Date.now()
   };
-  fs19.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
+  fs21.writeFileSync(RUNTIME_FILE2, JSON.stringify(runtime, null, 2), { mode: 384 });
   restrictFile(RUNTIME_FILE2);
   const config = new ConfigStore(defaultConfigStorePaths(CONFIG_DIR));
   if (config.loadError !== undefined)
@@ -12413,7 +13863,7 @@ async function main() {
     port: hookPort,
     endpointFile: HOOK_ENDPOINT_FILE,
     extensionPath
-  });
+  }, () => config.resolved().defaults ?? {});
   const telegram = new TelegramService(config, store, manager);
   hookHost.onAttachment(async (sessionId, filePath, caption) => {
     await telegram.sendAttachment(sessionId, filePath, caption);
@@ -12447,9 +13897,9 @@ async function main() {
     hookHost.stop();
     store.close();
     try {
-      const current = JSON.parse(fs19.readFileSync(RUNTIME_FILE2, "utf8"));
+      const current = JSON.parse(fs21.readFileSync(RUNTIME_FILE2, "utf8"));
       if (current.pid === process.pid)
-        fs19.rmSync(RUNTIME_FILE2);
+        fs21.rmSync(RUNTIME_FILE2);
     } catch {}
     process.exit(0);
   };
@@ -12482,14 +13932,14 @@ var init_src3 = __esm(() => {
   init_session_manager();
   init_telegram_service();
   init_store();
-  net3.setDefaultAutoSelectFamilyAttemptTimeout(3000);
+  net4.setDefaultAutoSelectFamilyAttemptTimeout(3000);
   main();
 });
 
 // packages/cli/src/index.ts
 init_src();
-import fs20 from "fs";
-import path19 from "path";
+import fs22 from "fs";
+import path21 from "path";
 
 // packages/cli/src/attach.ts
 import fs from "fs";
@@ -13129,18 +14579,289 @@ async function relayHookEvent(agent) {
   } catch {}
 }
 
+// packages/cli/src/mcp-server.ts
+init_src();
+import fs3 from "fs";
+import path4 from "path";
+var ASK_TIMEOUT_MS = 10 * 60000;
+var POST_TIMEOUT_MS2 = 5000;
+var TOOLS = [
+  {
+    name: "axterm_send_file",
+    description: "Send a file from this machine to the operator's messaging channel (the chat they are watching " + "this session from). Use when asked to send, share, deliver, or show a file, image, screenshot, " + "log, or document. Images arrive inline; anything else as a download.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file; relative paths resolve against the session's folder" },
+        caption: { type: "string", description: "Optional one-line caption" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "axterm_ask",
+    description: "Ask the operator a question with a fixed set of choices. The question appears both in this " + "terminal and in the operator's messaging channel, and whichever they answer first is used. " + "Prefer this over guessing when a decision is genuinely the operator's to make.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        questions: {
+          type: "array",
+          description: "One or more questions to put to the operator",
+          items: {
+            type: "object",
+            properties: {
+              question: { type: "string" },
+              options: { type: "array", items: { type: "string" }, description: "Omit for a free-text answer" },
+              multi: { type: "boolean", description: "Allow more than one choice" }
+            },
+            required: ["question"]
+          }
+        }
+      },
+      required: ["questions"]
+    }
+  }
+];
+
+class McpServer {
+  io;
+  clientElicits = false;
+  nextRequestId = 1;
+  pending = new Map;
+  constructor(io) {
+    this.io = io;
+  }
+  handle(raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (message.method === undefined && message.id !== undefined) {
+      const resolve = this.pending.get(Number(message.id));
+      this.pending.delete(Number(message.id));
+      resolve?.(message.result ?? message.error);
+      return;
+    }
+    this.dispatch(message);
+  }
+  send(message) {
+    this.io.write(`${JSON.stringify(message)}
+`);
+  }
+  async dispatch(message) {
+    const { id, method } = message;
+    switch (method) {
+      case "initialize": {
+        const params = message.params ?? {};
+        const capabilities = params["capabilities"];
+        this.clientElicits = typeof capabilities === "object" && capabilities !== null && "elicitation" in capabilities;
+        this.send({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: typeof params["protocolVersion"] === "string" ? params["protocolVersion"] : "2025-06-18",
+            capabilities: { tools: {} },
+            serverInfo: { name: "axterm", version: "1" }
+          }
+        });
+        return;
+      }
+      case "tools/list":
+        this.send({ jsonrpc: "2.0", id, result: { tools: TOOLS } });
+        return;
+      case "resources/list":
+        this.send({ jsonrpc: "2.0", id, result: { resources: [] } });
+        return;
+      case "prompts/list":
+        this.send({ jsonrpc: "2.0", id, result: { prompts: [] } });
+        return;
+      case "tools/call": {
+        const params = message.params ?? {};
+        const name = params["name"];
+        const args = params["arguments"] ?? {};
+        const outcome = name === "axterm_send_file" ? await this.sendFile(args) : name === "axterm_ask" ? await this.ask(args) : { text: `unknown tool: ${String(name)}`, isError: true };
+        this.send({
+          jsonrpc: "2.0",
+          id,
+          result: { content: [{ type: "text", text: outcome.text }], isError: outcome.isError }
+        });
+        return;
+      }
+      default:
+        if (id !== undefined)
+          this.send({ jsonrpc: "2.0", id, error: { code: -32601, message: `unknown: ${String(method)}` } });
+    }
+  }
+  target() {
+    const contextFile = this.io.env[MCP_CONTEXT_ENV];
+    if (contextFile !== undefined) {
+      try {
+        const context = JSON.parse(fs3.readFileSync(contextFile, "utf8"));
+        if (context.port && context.token && context.sessionId) {
+          return {
+            url: `http://127.0.0.1:${context.port}`,
+            headers: { "x-axterm-hook-token": context.token },
+            sessionId: context.sessionId,
+            launchToken: context.launchToken ?? ""
+          };
+        }
+      } catch {}
+      return;
+    }
+    const base = hookPostTarget(this.io.env, "omp");
+    const sessionId = this.io.env["AXTERM_SESSION_ID"];
+    if (!base || !sessionId)
+      return;
+    return {
+      url: base.url.replace(/\/hook\/[^/]+$/, ""),
+      headers: base.headers,
+      sessionId,
+      launchToken: this.io.env["AXTERM_LAUNCH_TOKEN"] ?? ""
+    };
+  }
+  async post(route, body, timeoutMs) {
+    const target = this.target();
+    if (!target)
+      return;
+    try {
+      return await this.io.fetch(`${target.url}${route}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...target.headers },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch {
+      return;
+    }
+  }
+  async sendFile(args) {
+    const file = typeof args["path"] === "string" ? args["path"] : "";
+    if (file === "")
+      return { text: "no path given", isError: true };
+    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 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)
+      return { text: "axterm did not answer", isError: true };
+    if (!res.ok)
+      return { text: `axterm could not deliver the file (${res.status})`, isError: true };
+    return { text: `sent ${resolved} to the operator's channel`, isError: false };
+  }
+  async ask(args) {
+    const questions = parseQuestions(args["questions"]);
+    if (questions.length === 0)
+      return { text: "no questions given", isError: true };
+    const target = this.target();
+    if (!target)
+      return { text: "axterm is not reachable from this session", isError: true };
+    const askId = `mcp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const channel = this.post("/hook/ask", { sessionId: target.sessionId, launchToken: target.launchToken, askId, questions }, ASK_TIMEOUT_MS).then(async (res) => {
+      if (!res?.ok)
+        return;
+      const body = await res.json().catch(() => {
+        return;
+      });
+      return body?.status === "answered" ? body.answers : undefined;
+    });
+    const terminal = this.clientElicits ? this.elicit(questions) : undefined;
+    const winner = await Promise.race([
+      channel.then((answers) => ({ from: "channel", answers })),
+      ...terminal ? [terminal.promise.then((answers) => ({ from: "terminal", answers }))] : []
+    ]);
+    if (winner.from === "channel") {
+      if (winner.answers) {
+        terminal?.cancel();
+        return { text: formatAskResult(questions, winner.answers).text, isError: false };
+      }
+      const settled = terminal ? await terminal.promise : undefined;
+      if (settled)
+        return { text: formatAskResult(questions, settled).text, isError: false };
+      return { text: "nobody answered the question", isError: true };
+    }
+    this.post("/hook/ask-cancel", { sessionId: target.sessionId, launchToken: target.launchToken, askId }, POST_TIMEOUT_MS2);
+    if (winner.answers)
+      return { text: formatAskResult(questions, winner.answers).text, isError: false };
+    return { text: "the operator dismissed the question in the terminal", isError: true };
+  }
+  elicit(questions) {
+    const id = this.nextRequestId++;
+    const { promise, resolve } = Promise.withResolvers();
+    this.pending.set(id, resolve);
+    this.send({
+      jsonrpc: "2.0",
+      id,
+      method: "elicitation/create",
+      params: {
+        message: questions.length === 1 ? questions[0].question : "axterm needs your input",
+        requestedSchema: elicitationSchema(questions)
+      }
+    });
+    return {
+      promise: promise.then((result) => answersFromElicitation(questions, result)),
+      cancel: () => {
+        if (!this.pending.has(id))
+          return;
+        this.pending.delete(id);
+        this.send({ jsonrpc: "2.0", method: "notifications/cancelled", params: { requestId: id, reason: "answered on the channel" } });
+      }
+    };
+  }
+}
+function parseQuestions(value) {
+  if (!Array.isArray(value))
+    return [];
+  const questions = [];
+  for (const raw of value) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const entry = raw;
+    if (typeof entry.question !== "string" || entry.question === "")
+      continue;
+    const options = Array.isArray(entry.options) ? entry.options.filter((option) => typeof option === "string").map((label) => ({ label })) : [];
+    questions.push({ question: entry.question, options, multi: entry.multi === true });
+  }
+  return questions;
+}
+function runMcpServer() {
+  const server = new McpServer({
+    write: (line) => process.stdout.write(line),
+    fetch,
+    env: process.env,
+    cwd: process.cwd()
+  });
+  let buffer = "";
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    for (;; ) {
+      const newline = buffer.indexOf(`
+`);
+      if (newline < 0)
+        break;
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (line !== "")
+        server.handle(line);
+    }
+  });
+  process.stdin.resume();
+}
+
 // packages/cli/src/update.ts
 init_src();
 import { spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs3 from "fs";
-import os3 from "os";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import { stdin as stdin2, stdout as stdout2 } from "process";
 // packages/cli/package.json
 var package_default = {
   name: "@layorixinc/axterm",
-  version: "0.1.0",
+  version: "0.4.0",
   type: "module",
   bin: {
     axterm: "dist/cli.js"
@@ -13214,7 +14935,7 @@ function assetName(platform, arch, isMusl) {
 function usesMusl() {
   if (process.platform !== "linux")
     return false;
-  if (fs3.existsSync("/etc/alpine-release"))
+  if (fs4.existsSync("/etc/alpine-release"))
     return true;
   const ldd = spawnSync("ldd", ["--version"], { encoding: "utf8" });
   return `${ldd.stdout ?? ""}${ldd.stderr ?? ""}`.toLowerCase().includes("musl");
@@ -13228,7 +14949,7 @@ function firstLine(command, args) {
 function detectOrigin(execPath) {
   const resolved = (() => {
     try {
-      return fs3.realpathSync(execPath);
+      return fs4.realpathSync(execPath);
     } catch {
       return execPath;
     }
@@ -13240,7 +14961,7 @@ function detectOrigin(execPath) {
     brewPrefix: firstLine("brew", ["--prefix"]),
     misePaths: misePaths === undefined ? [] : [misePaths],
     bunBin: firstLine("bun", ["pm", "bin", "-g"]),
-    npmBin: firstLine("npm", ["bin", "-g"])
+    npmBin: npmGlobalBin()
   });
 }
 var MANAGER_COMMAND = {
@@ -13249,8 +14970,11 @@ var MANAGER_COMMAND = {
   bun: (v) => `bun install -g ${PACKAGE}@${v}`,
   npm: (v) => `npm install -g ${PACKAGE}@${v}`
 };
-function runningFromSource() {
-  return Bun.main.endsWith(".ts") || Bun.main.endsWith(".js");
+function npmGlobalBin() {
+  const prefix = firstLine("npm", ["prefix", "-g"]);
+  if (prefix === undefined)
+    return;
+  return process.platform === "win32" ? prefix : path5.join(prefix, "bin");
 }
 async function download(url, into) {
   const response = await fetch(url, { signal: AbortSignal.timeout(600000) });
@@ -13267,7 +14991,7 @@ function checksumFor(sums, asset) {
   return;
 }
 function sha256(file) {
-  return createHash2("sha256").update(fs3.readFileSync(file)).digest("hex");
+  return createHash2("sha256").update(fs4.readFileSync(file)).digest("hex");
 }
 function ask2(question) {
   if (stdin2.isTTY !== true)
@@ -13296,21 +15020,26 @@ async function runUpdate(client, current, options) {
   console.log(t("cli.update.available", { latest: latest.version, current }));
   if (options.checkOnly)
     return;
-  if (runningFromSource()) {
+  const lane = classifyRuntimeLane(Bun.main);
+  if (lane === "checkout") {
     console.log(t("cli.update.notBinary"));
     return;
   }
+  if (lane === "bun" || lane === "npm") {
+    console.log(t("cli.update.viaManager", { manager: lane }));
+    console.log(t("cli.update.managerHint", { command: MANAGER_COMMAND[lane](latest.version) }));
+    return;
+  }
   const origin = detectOrigin(process.execPath);
   if (origin !== "binary") {
-    const command = MANAGER_COMMAND[origin](latest.version);
     console.log(t("cli.update.viaManager", { manager: origin }));
-    console.log(t("cli.update.managerHint", { command }));
+    console.log(t("cli.update.managerHint", { command: MANAGER_COMMAND[origin](latest.version) }));
     return;
   }
   const asset = assetName(process.platform, process.arch, usesMusl());
   const base = `${RELEASES}/v${latest.version}`;
-  const staging = fs3.mkdtempSync(path4.join(os3.tmpdir(), "axterm-update-"));
-  const downloaded = path4.join(staging, asset);
+  const staging = fs4.mkdtempSync(`${process.execPath}.update-`);
+  const downloaded = path5.join(staging, asset);
   try {
     console.log(t("cli.update.downloading", { asset }));
     await download(`${base}/${asset}`, downloaded);
@@ -13323,7 +15052,7 @@ async function runUpdate(client, current, options) {
       return;
     }
     if (process.platform !== "win32")
-      fs3.chmodSync(downloaded, 493);
+      fs4.chmodSync(downloaded, 493);
     const reported = spawnSync(downloaded, ["--version"], { encoding: "utf8" }).stdout?.trim();
     if (reported !== latest.version) {
       console.error(t("cli.update.wrongVersion", { got: reported ?? "nothing", want: latest.version }));
@@ -13342,6 +15071,9 @@ async function runUpdate(client, current, options) {
         return;
       }
     }
+    console.log(t("cli.update.swapping"));
+    applySwap(process.execPath, downloaded);
+    console.log(t("cli.update.done", { version: latest.version }));
     if (plan.stopDaemon) {
       console.log(t("cli.update.stopping"));
       await client.call("daemon.stop").catch(() => {
@@ -13350,9 +15082,6 @@ async function runUpdate(client, current, options) {
       client.close();
       await Bun.sleep(1500);
     }
-    console.log(t("cli.update.swapping"));
-    applySwap(process.execPath, downloaded);
-    console.log(t("cli.update.done", { version: latest.version }));
     if (plan.stale > 0)
       console.log(t("cli.update.staleDaemon", { count: plan.stale }));
     for (const id of plan.resume) {
@@ -13363,7 +15092,7 @@ async function runUpdate(client, current, options) {
         console.log(t("cli.update.restoreFailed", { id, reason: (result.stderr ?? "").trim() || "unknown" }));
     }
   } finally {
-    fs3.rmSync(staging, { recursive: true, force: true });
+    fs4.rmSync(staging, { recursive: true, force: true });
   }
 }
 function applySwap(target, downloaded) {
@@ -13372,16 +15101,16 @@ function applySwap(target, downloaded) {
   try {
     for (const step of steps) {
       if (step.op === "chmod")
-        fs3.chmodSync(step.from, 493);
+        fs4.chmodSync(step.from, 493);
       else if (step.op === "backup") {
-        fs3.renameSync(step.from, step.to);
+        fs4.renameSync(step.from, step.to);
         backup = step.to;
       } else
-        fs3.renameSync(step.from, step.to);
+        fs4.renameSync(step.from, step.to);
     }
   } catch (err) {
-    if (backup !== undefined && !fs3.existsSync(target))
-      fs3.renameSync(backup, target);
+    if (backup !== undefined && !fs4.existsSync(target))
+      fs4.renameSync(backup, target);
     throw err;
   }
 }
@@ -13454,7 +15183,7 @@ function printSessionTable(sessions) {
     console.log(row.map((cell, col) => cell.padEnd(widths[col])).join("  "));
   }
 }
-var realPath = (target) => fs20.realpathSync.native(target);
+var realPath = (target) => fs22.realpathSync.native(target);
 function scopedHere(sessions) {
   return sessionsInScope(sessions, process.cwd(), realPath);
 }
@@ -13464,22 +15193,10 @@ async function exitedIds(client, all) {
   return scoped.filter((s) => s.state === "exited").map((s) => s.id);
 }
 var help = () => t("cli.help");
-var KEY_SEQUENCES = {
-  approve: "\r",
-  deny: "\x1B[B\r",
-  enter: "\r",
-  esc: "\x1B",
-  up: "\x1B[A",
-  down: "\x1B[B",
-  left: "\x1B[D",
-  right: "\x1B[C",
-  tab: "\t",
-  space: " "
-};
 function readDotEnv(file = ".env") {
   const out = {};
   try {
-    for (const line of fs20.readFileSync(file, "utf8").split(/\r?\n/)) {
+    for (const line of fs22.readFileSync(file, "utf8").split(/\r?\n/)) {
       const m = line.match(/^([A-Z0-9_]+)=(.*)$/);
       if (m)
         out[m[1]] = m[2].trim();
@@ -13490,7 +15207,7 @@ function readDotEnv(file = ".env") {
 function configuredLocale() {
   try {
     const file = resolvePaths(currentPathEnv()).configFile;
-    const raw = JSON.parse(fs20.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs22.readFileSync(file, "utf8"));
     return typeof raw.locale === "string" ? raw.locale : undefined;
   } catch {
     return;
@@ -13507,6 +15224,10 @@ async function main2() {
     await relayHookEvent(argv[1]);
     return;
   }
+  if (isMcpInvocation(argv)) {
+    runMcpServer();
+    return;
+  }
   const [command, ...rest] = argv;
   setLocale(resolveLocale({ configured: configuredLocale(), env: process.env }));
   const { flags, positional, passthrough } = parseArgs(rest);
@@ -13525,9 +15246,9 @@ async function main2() {
   if (health !== undefined && shouldOfferSetup(health, command, flags)) {
     const header2 = health.status === "invalid" ? "wizard.invalid" : health.status === "incomplete" ? "wizard.incomplete" : "wizard.needed";
     console.log(t(header2));
-    const detail = describeHealth(health);
-    if (detail.length > 0)
-      console.log(detail);
+    const detail2 = describeHealth(health);
+    if (detail2.length > 0)
+      console.log(detail2);
     console.log(t("wizard.hint"));
     await runSetup(client, await client.call("config.raw"));
   }
@@ -13540,6 +15261,7 @@ async function main2() {
           name: flags.get("name"),
           shell: flags.get("shell"),
           agent: flags.get("agent"),
+          autoApprove: typeof flags.get("auto-approve") === "boolean" ? flags.get("auto-approve") : undefined,
           agentArgs: passthrough,
           worktreeBranch: flags.get("worktree"),
           worktreeBase: flags.get("base"),
@@ -13568,7 +15290,16 @@ async function main2() {
         break;
       }
       case "attach": {
-        const id = positional[0];
+        let id = positional[0];
+        if (flags.get("last") === true) {
+          const all = await client.call("session.list");
+          const pool = flags.get("all") === true ? all : scopedHere(all);
+          const last = mostRecentSession(pool);
+          if (!last)
+            throw new Error(t("cli.attach.noRecent"));
+          console.log(t("cli.attach.picked", { id: last.shortId, name: last.name }));
+          id = last.id;
+        }
         if (!id)
           throw new Error(t("cli.usage.attach"));
         await attachSession(client, id, flags.get("host-status") === "orca");
@@ -13608,8 +15339,8 @@ async function main2() {
       case "key": {
         const [id, name] = positional;
         if (!id || !name)
-          throw new Error(t("cli.usage.key", { keys: Object.keys(KEY_SEQUENCES).join("|") }));
-        const seq = KEY_SEQUENCES[name];
+          throw new Error(t("cli.usage.key", { keys: KEY_NAMES.join("|") }));
+        const seq = keySequence(name);
         if (seq === undefined)
           throw new Error(t("cli.key.unknown", { name }));
         await client.call("terminal.write", { id, dataB64: Buffer.from(seq, "utf8").toString("base64") });
@@ -13620,8 +15351,8 @@ async function main2() {
         const [id, indexArg] = positional;
         if (!id || indexArg === undefined)
           throw new Error(t("cli.usage.choose"));
-        const keys = buildMenuSelectKeys(Number(indexArg));
-        await client.call("terminal.write", { id, dataB64: Buffer.from(keys, "utf8").toString("base64") });
+        const keys2 = buildMenuSelectKeys(Number(indexArg));
+        await client.call("terminal.write", { id, dataB64: Buffer.from(keys2, "utf8").toString("base64") });
         console.log(t("cli.session.selected", { index: indexArg }));
         break;
       }
@@ -13656,9 +15387,10 @@ async function main2() {
           console.log(value === undefined ? "" : String(value));
         } else if (sub === "set") {
           const [, dottedPath, ...rest2] = positional;
-          if (!dottedPath || rest2.length === 0)
+          const value = passthrough.length > 0 ? passthrough : rest2.join(" ");
+          if (!dottedPath || value.length === 0)
             throw new Error(t("cli.usage.configSet"));
-          await client.call("config.set", { path: dottedPath, value: rest2.join(" ") });
+          await client.call("config.set", { path: dottedPath, value });
           console.log(t("cli.config.set", { path: dottedPath }));
         } else if (sub === "unset") {
           const dottedPath = positional[1];
@@ -13697,8 +15429,8 @@ async function main2() {
       case "project": {
         const sub = positional[0] ?? "list";
         if (sub === "add") {
-          const dir = positional[1] ? path19.resolve(positional[1]) : process.cwd();
-          const alias = positional[2] ?? path19.basename(dir);
+          const dir = positional[1] ? path21.resolve(positional[1]) : process.cwd();
+          const alias = positional[2] ?? path21.basename(dir);
           const projects = await client.call("project.add", {
             alias,
             path: dir
@@ -13757,6 +15489,24 @@ async function main2() {
         }
         break;
       }
+      case "quota": {
+        const report = await client.call("quota.report").catch(() => {
+          return;
+        });
+        if (report === undefined) {
+          console.log(t("doctor.daemon.old"));
+          break;
+        }
+        if (report.checks.length === 0) {
+          console.log(t("cli.quota.none"));
+          break;
+        }
+        const GLYPHS = { ok: "\u2713", info: "\u2023", warn: "!", fail: "\u2717" };
+        for (const check of report.checks) {
+          console.log(`  ${GLYPHS[check.status]} ${t(check.key, check.params ?? {})}`);
+        }
+        break;
+      }
       case "worktree": {
         const sub = positional[0] ?? "list";
         if (sub === "list") {
@@ -13913,6 +15663,28 @@ async function main2() {
           console.log(JSON.stringify(await client.call("telegram.doctor"), null, 2));
         } else if (sub === "status") {
           console.log(JSON.stringify(await client.call("telegram.status"), null, 2));
+        } else if (sub === "discover") {
+          const token = flags.get("token");
+          const found = await client.call("telegram.discover", {
+            ...token !== undefined ? { botToken: token } : {}
+          });
+          if (found.chats.length > 0) {
+            console.log(t("cli.telegram.discoverChats"));
+            for (const chat of found.chats) {
+              const marks = [chat.type, chat.isForum ? undefined : t("cli.telegram.topicsOff")].filter((m) => m !== undefined).join(" \u2014 ");
+              console.log(`  ${String(chat.id).padEnd(16)} ${(chat.title ?? "").padEnd(24)} ${marks}`);
+            }
+          } else {
+            console.log(t("cli.telegram.discoverNone"));
+            console.log(t("cli.telegram.discoverHint"));
+          }
+          if (found.users.length > 0) {
+            console.log(t("cli.telegram.discoverUsers"));
+            for (const user of found.users) {
+              const label = [user.username !== undefined ? `@${user.username}` : undefined, user.name].filter((part) => part !== undefined).join(" ");
+              console.log(`  ${String(user.id).padEnd(16)} ${label}`);
+            }
+          }
         } else {
           throw new Error(t("cli.usage.telegram"));
         }