usebeeline 0.0.122 → 0.0.124

package/dist/usebeeline.mjs

@@ -11315,10 +11315,10 @@ __export(self_update_exports, {
 });
 import { createHash as createHash8 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
-import { access as access2, chmod as chmod6, lstat as lstat4, mkdir as mkdir18, open, readFile as readFile11, rename as rename6, rm as rm6, symlink as symlink3, writeFile as writeFile11 } from "node:fs/promises";
-import { spawn as spawn8 } from "node:child_process";
+import { access as access2, chmod as chmod6, lstat as lstat4, mkdir as mkdir18, open, readFile as readFile11, rename as rename6, rm as rm7, symlink as symlink3, writeFile as writeFile11 } from "node:fs/promises";
+import { spawn as spawn9 } from "node:child_process";
 import { homedir as homedir12 } from "node:os";
-import { dirname as dirname16, join as join13, resolve as resolve27 } from "node:path";
+import { dirname as dirname16, join as join14, resolve as resolve27 } from "node:path";
 function anchorLayout(rawLibDir) {
   const libDir = resolve27(rawLibDir);
   const segments = libDir.split(/[/\\]/);
@@ -11391,7 +11391,7 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join13(bundleDir, "lib", "beeline", "bundle.json"), join13(bundleDir, "bundle.json")];
+  return [join14(bundleDir, "lib", "beeline", "bundle.json"), join14(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
@@ -11415,7 +11415,7 @@ async function readBundleJson(bundleDir) {
   }
 }
 function updateStatePath(layout) {
-  return join13(layout.releasesRoot, ".state", "update-state.json");
+  return join14(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
@@ -11425,7 +11425,7 @@ async function readUpdateState(layout) {
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir18(join13(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir18(join14(layout.releasesRoot, ".state"), { recursive: true });
   await writeFile11(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -11489,7 +11489,7 @@ async function fetchText(url, fetchImpl) {
 }
 function run(command, args, timeoutMs) {
   return new Promise((resolveRun) => {
-    const child = spawn8(command, args, { stdio: ["ignore", "ignore", "pipe"] });
+    const child = spawn9(command, args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (chunk) => {
@@ -11507,7 +11507,7 @@ function run(command, args, timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join13(bundleDir, BUNDLE_ENTRYPOINT), join13(bundleDir, "beeline-cli.mjs")];
+  return [join14(bundleDir, BUNDLE_ENTRYPOINT), join14(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
@@ -11526,8 +11526,8 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log2 = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   const releaseId = sanitizeReleaseId(published.commit ?? published.version ?? `release-${Date.now()}`);
-  const releaseDir = join13(layout.releasesRoot, releaseId);
-  const okMarker = join13(releaseDir, ".stage-ok");
+  const releaseDir = join14(layout.releasesRoot, releaseId);
+  const okMarker = join14(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
     const recorded = await readFile11(okMarker, "utf8");
@@ -11537,7 +11537,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   } catch {
   }
   await mkdir18(releaseDir, { recursive: true });
-  const tempArchive = join13(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  const tempArchive = join14(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
     log2(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
@@ -11559,7 +11559,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     }
     await writeFile11(tempArchive, Buffer.concat(chunks), { mode: 384 });
     const entries = (await new Promise((resolveList, rejectList) => {
-      const child = spawn8("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
+      const child = spawn9("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
       let out = "";
       child.stdout?.on("data", (chunk) => {
         out += chunk.toString("utf8");
@@ -11577,13 +11577,13 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract2.stderr}`);
     for (const relative3 of requiredBundlePaths()) {
       try {
-        await access2(join13(releaseDir, relative3), fsConstants2.F_OK);
+        await access2(join14(releaseDir, relative3), fsConstants2.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative3}`);
       }
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join13(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
+      const probe = await run(process.execPath, [join14(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
       if (probe.status !== 0) {
         throw new Error(`staged bundle failed its startup smoke test (--version exited ${probe.status})${probe.stderr ? `: ${probe.stderr.trim()}` : ""}`);
       }
@@ -11594,10 +11594,10 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
-      await rm6(releaseDir, { recursive: true, force: true });
+      await rm7(releaseDir, { recursive: true, force: true });
     throw error;
   } finally {
-    await rm6(tempArchive, { force: true });
+    await rm7(tempArchive, { force: true });
   }
 }
 function forwarderScript(tool) {
@@ -11621,8 +11621,8 @@ async function replaceFile(path, contents, mode) {
   await rename6(temp, path);
 }
 async function activateRelease(layout, releaseId) {
-  const releaseDir = join13(layout.releasesRoot, releaseId);
-  await access2(join13(releaseDir, BUNDLE_ENTRYPOINT), fsConstants2.F_OK);
+  const releaseDir = join14(layout.releasesRoot, releaseId);
+  await access2(join14(releaseDir, BUNDLE_ENTRYPOINT), fsConstants2.F_OK);
   await mkdir18(layout.releasesRoot, { recursive: true });
   await mkdir18(layout.binDir, { recursive: true });
   let previousReleaseId = await activeReleaseId(layout);
@@ -11630,12 +11630,12 @@ async function activateRelease(layout, releaseId) {
   if (kind === "directory") {
     const legacyIdentity = await readBundleJson(layout.libDir);
     const legacyId = sanitizeReleaseId(legacyIdentity?.commit ?? legacyIdentity?.version ?? `legacy-${Date.now()}`);
-    const legacyDir = join13(layout.releasesRoot, legacyId);
+    const legacyDir = join14(layout.releasesRoot, legacyId);
     try {
       await access2(legacyDir, fsConstants2.F_OK);
       previousReleaseId = `${legacyId}-${Date.now()}`;
-      await rename6(layout.libDir, join13(layout.releasesRoot, previousReleaseId));
-      await normalizeLegacyBundleShape(join13(layout.releasesRoot, previousReleaseId));
+      await rename6(layout.libDir, join14(layout.releasesRoot, previousReleaseId));
+      await normalizeLegacyBundleShape(join14(layout.releasesRoot, previousReleaseId));
     } catch {
       await rename6(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
@@ -11643,19 +11643,19 @@ async function activateRelease(layout, releaseId) {
     }
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
-  await rm6(tempLink, { force: true });
-  await symlink3(join13("beeline-releases", releaseId), tempLink);
+  await rm7(tempLink, { force: true });
+  await symlink3(join14("beeline-releases", releaseId), tempLink);
   await rename6(tempLink, layout.libDir);
   await fsyncDir(dirname16(layout.libDir));
   await writeBinForwarders(layout, releaseDir);
   return { previousReleaseId };
 }
 async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join13(bundleDir, "lib", "beeline");
+  const innerLib = join14(bundleDir, "lib", "beeline");
   let anyFlat = false;
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access2(join13(bundleDir, name), fsConstants2.F_OK);
+      await access2(join14(bundleDir, name), fsConstants2.F_OK);
       anyFlat = true;
       break;
     } catch {
@@ -11666,11 +11666,11 @@ async function normalizeLegacyBundleShape(bundleDir) {
   await mkdir18(innerLib, { recursive: true });
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access2(join13(innerLib, name), fsConstants2.F_OK);
+      await access2(join14(innerLib, name), fsConstants2.F_OK);
       continue;
     } catch {
     }
-    await rename6(join13(bundleDir, name), join13(innerLib, name)).catch(() => void 0);
+    await rename6(join14(bundleDir, name), join14(innerLib, name)).catch(() => void 0);
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
@@ -11679,13 +11679,13 @@ async function writeBinForwarders(layout, activeBundleRoot) {
     ...Object.entries(FORWARDER_ALIASES).map(([alias, tool]) => [alias, tool])
   ];
   for (const [name, tool] of entries) {
-    const target = join13(activeBundleRoot, "bin", tool);
+    const target = join14(activeBundleRoot, "bin", tool);
     try {
       await access2(target, fsConstants2.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join13(layout.binDir, name), forwarderScript(tool), 493);
+    await replaceFile(join14(layout.binDir, name), forwarderScript(tool), 493);
   }
 }
 async function repairInstallForwarders(layout, opts = {}) {
@@ -11694,7 +11694,7 @@ async function repairInstallForwarders(layout, opts = {}) {
   const forwarderHealthy = async (name, tool) => {
     let current;
     try {
-      current = await readFile11(join13(layout.binDir, name), "utf8");
+      current = await readFile11(join14(layout.binDir, name), "utf8");
     } catch {
       current = void 0;
     }
@@ -11713,19 +11713,19 @@ async function repairInstallForwarders(layout, opts = {}) {
   return true;
 }
 async function rollbackToPreviousRelease(layout, previousReleaseId) {
-  const releaseDir = join13(layout.releasesRoot, previousReleaseId);
+  const releaseDir = join14(layout.releasesRoot, previousReleaseId);
   const entrypoint = await resolveBundleEntrypoint(releaseDir);
   if (!entrypoint) {
     throw new Error(`release ${previousReleaseId} has no runnable CLI entrypoint`);
   }
   const tempLink = `${layout.libDir}.rollback-${process.pid}`;
-  await rm6(tempLink, { force: true });
-  await symlink3(join13("beeline-releases", previousReleaseId), tempLink);
+  await rm7(tempLink, { force: true });
+  await symlink3(join14("beeline-releases", previousReleaseId), tempLink);
   await rename6(tempLink, layout.libDir);
   await fsyncDir(dirname16(layout.libDir));
 }
 function updateAttemptPath(layout) {
-  return join13(layout.releasesRoot, ".state", "update-attempt.json");
+  return join14(layout.releasesRoot, ".state", "update-attempt.json");
 }
 async function readUpdateAttempt(layout) {
   try {
@@ -11739,7 +11739,7 @@ async function readUpdateAttempt(layout) {
   }
 }
 async function writeUpdateAttempt(layout, record3) {
-  await mkdir18(join13(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir18(join14(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateAttemptPath(layout);
   const staged = `${path}.${process.pid}.tmp`;
   await writeFile11(staged, `${JSON.stringify(record3, null, 2)}
@@ -13438,6 +13438,7 @@ import { accessSync as accessSync2, constants as constants2, existsSync as exist
 import { basename as basename2, dirname as dirname2, resolve as resolve2 } from "node:path";
 
 // apps/body/dist/agent-command.js
+import { spawn as spawn3 } from "node:child_process";
 import { accessSync, constants, existsSync as existsSync2, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
@@ -14040,17 +14041,44 @@ var AGENT_EXECUTABLES = {
 var ADAPTER_INSTALL_COMMANDS = {
   codex: {
     command: "npm",
-    args: ["install", "-g", "@agentclientprotocol/codex-acp"]
+    args: ["install", "-g", "@agentclientprotocol/codex-acp@latest"]
   },
   claude: {
     command: "npm",
-    args: ["install", "-g", "@agentclientprotocol/claude-agent-acp"]
+    args: ["install", "-g", "@agentclientprotocol/claude-agent-acp@latest"]
   },
   pi: {
     command: "npm",
-    args: ["install", "-g", "pi-acp"]
+    args: ["install", "-g", "pi-acp@latest"]
   }
 };
+function latestAdapterInstallCommand(kind) {
+  return kind === "codex" || kind === "claude" || kind === "pi" ? ADAPTER_INSTALL_COMMANDS[kind] : void 0;
+}
+async function runAdapterInstall(install, opts = {}) {
+  await new Promise((resolveInstall, rejectInstall) => {
+    const child = spawn3(install.command, install.args, {
+      ...opts.cwd ? { cwd: opts.cwd } : {},
+      env: opts.env ?? process.env,
+      stdio: opts.stdio ?? "inherit"
+    });
+    child.once("error", rejectInstall);
+    child.once("exit", (code, signal) => {
+      if (code === 0)
+        resolveInstall();
+      else {
+        rejectInstall(new Error(signal ? `${install.command} was terminated by ${signal}` : `${install.command} exited with status ${code ?? "unknown"}`));
+      }
+    });
+  });
+}
+async function installLatestAgentAdapter(kind, opts = {}) {
+  const install = latestAdapterInstallCommand(kind);
+  if (!install)
+    return false;
+  await runAdapterInstall(install, opts);
+  return true;
+}
 function adapterInstallHint(kind) {
   return formatAdapterInstallCommand(ADAPTER_INSTALL_COMMANDS[kind]);
 }
@@ -14208,7 +14236,7 @@ function resolveAgentCommand(opts) {
     throw new Error("--agent-command may only be used with --agent custom");
   }
   if (typedKind === "codex") {
-    requireExecutable("codex", env, cwd, "Codex CLI not found. Install it with `npm install -g @openai/codex`, then retry with `--agent codex`.");
+    requireExecutable("codex", env, cwd, "Codex CLI not found. Install it with `npm install -g @openai/codex@latest`, then retry with `--agent codex`.");
     const command2 = requireExecutable("codex-acp", env, cwd, `Codex ACP adapter not found. Install it with \`${adapterInstallHint("codex")}\`, then retry with \`--agent codex\`.`);
     return { kind: typedKind, command: command2, args: [] };
   }
@@ -14225,7 +14253,7 @@ function resolveAgentCommand(opts) {
     return { kind: typedKind, command: command2, args: ["acp"] };
   }
   if (typedKind === "pi") {
-    requireExecutable("pi", env, cwd, "Pi coding agent not found. Install it with `npm install -g @mariozechner/pi-coding-agent`, then retry with `--agent pi`.");
+    requireExecutable("pi", env, cwd, "Pi coding agent not found. Install it with `npm install -g @mariozechner/pi-coding-agent@latest`, then retry with `--agent pi`.");
     const command2 = requireExecutable("pi-acp", env, cwd, `Pi needs an ACP adapter. Install it with \`${adapterInstallHint("pi")}\`, then retry with \`--agent pi\`.`);
     return { kind: typedKind, command: command2, args: [] };
   }
@@ -14607,7 +14635,7 @@ function parseSandboxMaskEnv(env) {
 }
 
 // apps/body/dist/squire-host.js
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync4, lstatSync, mkdirSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir2 } from "node:os";
@@ -14706,7 +14734,7 @@ WantedBy=default.target
 function spawnSquireServer(env, locateNpx) {
   const launch = locateNpx ? squireServerCommand() : { command: "npx", args: [...SQUIRE_SERVER_ARGS], pathPrefix: "" };
   const path = [launch.pathPrefix, env.PATH || "/usr/bin:/bin"].filter(Boolean).join(":");
-  const child = spawn3(launch.command, launch.args, {
+  const child = spawn4(launch.command, launch.args, {
     env: { ...env, PATH: path },
     stdio: "inherit"
   });
@@ -14745,1321 +14773,1317 @@ var DEFAULT_ACCESS_POLICY = DEFAULT_AGENT_ACCESS_POLICY;
 var LEGACY_ACCESS_POLICY = "everyone";
 var ACCESS_REFUSAL_WINDOW_MS = 60 * 60 * 1e3;
 
-// apps/body/dist/model-catalog.js
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve as resolve5 } from "node:path";
-
-// apps/body/dist/acp.js
-import { spawn as spawn4 } from "node:child_process";
-import { EventEmitter } from "node:events";
-
-// apps/body/dist/harness-capabilities.js
-function harnessHonorsSessionSystemPrompt(agentCommand) {
-  return Boolean(agentCommand && /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i.test(agentCommand));
+// apps/body/dist/model-types.js
+var ALLOWED = /* @__PURE__ */ new Set(["model", "thought_level", "effort", "reasoning_effort"]);
+function isAllowedAgentModelConfigCategory(category) {
+  return ALLOWED.has(category);
 }
-var GROK_WARM_SESSION_IDLE_MS = 30 * 6e4;
-function cornerAutonomyModeCandidates(agentCommand) {
-  if (agentCommand && /(^|[/\\])codex-acp(\.[a-z]+)?$/i.test(agentCommand)) {
-    return ["agent-full-access"];
-  }
-  if (agentCommand && /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i.test(agentCommand)) {
-    return ["bypassPermissions"];
-  }
-  if (agentCommand && /(^|[/\\])grok(\.[a-z]+)?$/i.test(agentCommand))
-    return [];
-  if (agentCommand && /(^|[/\\])pi-acp(\.[a-z]+)?$/i.test(agentCommand))
-    return [];
-  return ["agent", "edit", "code"];
+
+// apps/body/dist/model-config.js
+import { lstatSync as lstatSync2, readFileSync as readFileSync2 } from "node:fs";
+import { basename as basename3, resolve as resolve4 } from "node:path";
+var GROK_SESSION_MODEL_AXIS_ID = "beeline:grok-session-model";
+var GROK_LAUNCH_EFFORT_AXIS_ID = "beeline:grok-launch-reasoning-effort";
+function isGrokAgentCommand(agent) {
+  if (agent.kind === "grok")
+    return true;
+  if (agent.kind && agent.kind !== "custom")
+    return false;
+  return /^grok(?:\.[a-z0-9]+)?$/i.test(basename3(agent.command));
 }
-function roomModeCandidates(agentCommand, options = {}) {
-  if (options.osSandbox && agentCommand && /(^|[/\\])codex-acp(\.[a-z]+)?$/i.test(agentCommand)) {
-    return ["agent-full-access"];
+function agentArgsWithModelSelection(agent, selection) {
+  const original = [...agent.args];
+  if (!selection || !isGrokAgentCommand(agent) || !original.includes("agent") || !original.includes("stdio")) {
+    return original;
   }
-  return ["read-only", "readonly"];
-}
-
-// apps/body/dist/harness-tool-scope.js
-var CLAUDE_TOOL_SCOPE_SETTINGS = { disableClaudeAiConnectors: true };
-var CLAUDE_PROFILE = {
-  // `settingSources: ['user']` admits the sanitized user MCP copy
-  // while rejecting repository/local/plugin MCP. `strictMcpConfig` cannot be
-  // used because it would reject the user copy too. Account-bound claude.ai
-  // cloud connectors remain off independently.
-  enforcement: "config-isolated",
-  note: "claude-agent-acp forwards _meta.claudeCode.options to the Claude Agent SDK; user-only settingSources loads MCP from the isolated CLAUDE_CONFIG_DIR without repository/local settings, while disableClaudeAiConnectors keeps account-bound connectors off",
-  sessionMeta: {
-    claudeCode: {
-      options: {
-        // Only the sanitized user config in the isolated CLAUDE_CONFIG_DIR;
-        // never a repository's .mcp.json, local settings, or plugins.
-        settingSources: ["user"],
-        // Account-bound claude.ai cloud connectors are not fetched at all.
-        settings: CLAUDE_TOOL_SCOPE_SETTINGS
-      }
-    }
-  },
-  metaSystemPrompt: true
-};
-var PROFILES = [
-  { match: /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i, profile: CLAUDE_PROFILE },
-  {
-    match: /(^|[/\\])codex-acp(\.[a-z]+)?$/i,
-    profile: {
-      enforcement: "config-isolated",
-      note: "codex-acp merges the session's MCP servers into $CODEX_HOME/config.toml's own [mcp_servers] instead of replacing them, so only an isolated CODEX_HOME scopes the session; the ChatGPT account's codex_apps connectors survive either way"
-    }
-  },
-  {
-    match: /(^|[/\\])pi-acp(\.[a-z]+)?$/i,
-    profile: {
-      enforcement: "config-isolated",
-      note: "pi-acp 0.0.33 still stores session/new mcpServers and never reads them; pi 0.85.1 itself has no MCP client, while optional pi-mcp-adapter reads $PI_CODING_AGENT_DIR/mcp.json and isolated homes exclude the settings.json that would load it"
-    }
-  },
-  {
-    match: /(^|[/\\])grok(\.[a-z]+)?$/i,
-    profile: {
-      enforcement: "config-isolated",
-      note: "grok loads the operator's own ~/.grok MCP servers even when session/new passes an empty mcpServers list (measured live), so only an isolated GROK_HOME scopes the session; no account-bound connector surface was found"
-    }
-  },
-  {
-    match: /(^|[/\\])buzz-agent(\.[a-z]+)?$/i,
-    profile: {
-      enforcement: "allowlisted",
-      note: "buzz-agent mounts only the MCP servers the daemon passes; it has no operator-global tool config"
+  const stripped = [];
+  for (let index = 0; index < original.length; index += 1) {
+    const arg = original[index];
+    if (arg === "-m" || arg === "--model" || arg === "--reasoning-effort") {
+      index += 1;
+      continue;
     }
-  },
-  {
-    match: CURSOR_HARNESS_COMMAND,
-    profile: {
-      enforcement: "config-isolated",
-      note: "cursor-acp-bridge writes session/new mcpServers into the isolated CURSOR_HOME mcp.json and the isolated $HOME/.cursor/mcp.json cursor-agent loads; it never writes the operator ~/.cursor"
+    if (arg.startsWith("--model=") || arg.startsWith("--reasoning-effort=") || /^-m=/.test(arg)) {
+      continue;
     }
+    stripped.push(arg);
   }
-];
-function sessionToolScopeMeta(agentCommand) {
-  const meta = matchProfile(agentCommand)?.sessionMeta;
-  return meta ? JSON.parse(JSON.stringify(meta)) : void 0;
-}
-function harnessReadsMetaSystemPrompt(agentCommand) {
-  return matchProfile(agentCommand)?.metaSystemPrompt === true;
+  const stdioIndex = stripped.lastIndexOf("stdio");
+  const configured = [
+    ...selection.model ? ["--model", selection.model] : [],
+    ...selection.effort ? ["--reasoning-effort", selection.effort] : []
+  ];
+  stripped.splice(stdioIndex, 0, ...configured);
+  return stripped;
 }
-function matchProfile(agentCommand) {
-  if (!agentCommand)
-    return void 0;
-  for (const { match, profile } of PROFILES) {
-    if (match.test(agentCommand))
-      return profile;
-  }
+function advertisedChoiceId(choice) {
+  if (typeof choice.id === "string" && choice.id.length > 0)
+    return choice.id;
+  if (typeof choice.value === "string" && choice.value.length > 0)
+    return choice.value;
   return void 0;
 }
-
-// apps/body/dist/acp.js
-var STDERR_TAIL_MAX_CHARS2 = 2e3;
-function braceDelta(line) {
-  let delta = 0;
-  for (const char of line) {
-    if (char === "{")
-      delta += 1;
-    else if (char === "}")
-      delta -= 1;
-  }
-  return delta;
+function sortModelChoicesNewestFirst(choices) {
+  return choices.map((choice, index) => ({ choice, index })).sort((left, right) => {
+    const leftParts = left.choice.id.match(/\d+/g)?.map(Number) ?? [];
+    const rightParts = right.choice.id.match(/\d+/g)?.map(Number) ?? [];
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+      const delta = (rightParts[index] ?? -1) - (leftParts[index] ?? -1);
+      if (delta !== 0)
+        return delta;
+    }
+    return left.index - right.index;
+  }).map(({ choice }) => choice);
 }
-function meaningfulHarnessStderr(tail) {
-  const lines = tail.split(/\r?\n/);
-  const kept = [];
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index];
-    if (!/error handling notification/i.test(line)) {
-      kept.push(line);
+function parseAdvertisedConfigOptions(raw, preferredModelId, includeLaunchEffort = false) {
+  const configOptions = raw?.configOptions;
+  const result = [];
+  for (const entry of Array.isArray(configOptions) ? configOptions : []) {
+    if (!entry || typeof entry !== "object")
       continue;
+    const record3 = entry;
+    const id = record3.id;
+    const category = record3.category;
+    if (typeof id !== "string" || typeof category !== "string")
+      continue;
+    const rawChoices = Array.isArray(record3.options) ? record3.options : [];
+    const choices = [];
+    for (const rawChoice of rawChoices) {
+      if (!rawChoice || typeof rawChoice !== "object")
+        continue;
+      const choice = rawChoice;
+      const choiceId = advertisedChoiceId(choice);
+      if (!choiceId)
+        continue;
+      choices.push({
+        id: choiceId,
+        ...typeof choice.name === "string" ? { name: choice.name } : {}
+      });
     }
-    const block2 = [line];
-    let depth = braceDelta(line);
-    if (depth === 0 && lines[index + 1]?.trimStart().startsWith("{")) {
-      index += 1;
-      block2.push(lines[index]);
-      depth = braceDelta(lines[index]);
-    }
-    while (depth > 0 && index + 1 < lines.length) {
-      index += 1;
-      block2.push(lines[index]);
-      depth += braceDelta(lines[index]);
-    }
-    if (!/notifications\/initialized/.test(block2.join("\n")))
-      kept.push(...block2);
-  }
-  return kept.join("\n").trim();
-}
-function flattenHarnessCause(tail) {
-  return meaningfulHarnessStderr(tail).replace(/\s+/g, " ").trim();
-}
-var AcpRequestTimeoutError = class extends Error {
-  method;
-  timeoutMs;
-  inactivity;
-  code = "ACP_REQUEST_TIMEOUT";
-  constructor(method, timeoutMs, stderrTail = "", inactivity = false, detail = "") {
-    const meaningful = flattenHarnessCause(stderrTail);
-    const suffix = meaningful ? `; harness stderr: ${meaningful}` : "";
-    super(`ACP ${method} timed out after ${timeoutMs}ms${inactivity ? " of inactivity" : ""}${detail ? ` (${detail})` : ""}${suffix}`);
-    this.method = method;
-    this.timeoutMs = timeoutMs;
-    this.inactivity = inactivity;
-    this.name = "AcpRequestTimeoutError";
+    result.push({
+      id,
+      category,
+      ...typeof record3.currentValue === "string" ? { currentValue: record3.currentValue } : {},
+      options: category === "model" ? sortModelChoicesNewestFirst(choices) : choices
+    });
   }
-};
-function killChildProcessGroup(child, signal) {
-  if (!child.pid)
-    return;
-  try {
-    if (process.platform === "win32")
-      child.kill(signal);
-    else
-      process.kill(-child.pid, signal);
-  } catch (error) {
-    if (error.code !== "ESRCH")
-      throw error;
+  const models = raw?.models;
+  if (!models || typeof models !== "object")
+    return result;
+  const modelState = models;
+  const availableModels = Array.isArray(modelState.availableModels) ? modelState.availableModels : [];
+  const modelChoices = [];
+  for (const entry of availableModels) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const model = entry;
+    if (typeof model.modelId !== "string" || !model.modelId)
+      continue;
+    modelChoices.push({
+      id: model.modelId,
+      ...typeof model.name === "string" ? { name: model.name } : {}
+    });
   }
-}
-function promptPayloadNote(prompt) {
-  if (typeof prompt === "string")
-    return "";
-  const images = prompt.filter((block2) => block2.type === "image");
-  if (!images.length)
-    return "";
-  const bytes = images.reduce((total, block2) => total + Math.floor(block2.data.length * 3 / 4), 0);
-  return `prompt carried ${images.length} inline image${images.length === 1 ? "" : "s"}, ${Math.round(bytes / 1024)} KB`;
-}
-function parseAvailableCommands(value) {
-  if (!Array.isArray(value))
-    return [];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const entry of value) {
+  const currentModelId = typeof modelState.currentModelId === "string" ? modelState.currentModelId : void 0;
+  if (modelChoices.length > 0 && !result.some((axis) => axis.category === "model")) {
+    result.push({
+      id: GROK_SESSION_MODEL_AXIS_ID,
+      category: "model",
+      ...currentModelId ? { currentValue: currentModelId } : {},
+      options: sortModelChoicesNewestFirst(modelChoices)
+    });
+  }
+  const effortModelId = preferredModelId ?? currentModelId;
+  const currentModel = availableModels.find((entry) => entry && typeof entry === "object" && entry.modelId === effortModelId);
+  const meta = currentModel?._meta;
+  const modelMeta = meta && typeof meta === "object" ? meta : void 0;
+  const efforts = Array.isArray(modelMeta?.reasoningEfforts) ? modelMeta.reasoningEfforts : [];
+  const effortChoices = [];
+  for (const entry of efforts) {
     if (!entry || typeof entry !== "object")
       continue;
-    const record3 = entry;
-    const rawName = typeof record3.name === "string" ? record3.name.trim().replace(/^\/+/, "") : "";
-    if (!rawName || rawName.length > 80 || seen.has(rawName))
+    const effort = entry;
+    const id = advertisedChoiceId(effort);
+    if (!id)
       continue;
-    seen.add(rawName);
-    const description = typeof record3.description === "string" && record3.description.trim() ? record3.description.trim().slice(0, 300) : void 0;
-    const input = record3.input;
-    const hintRaw = input && typeof input.hint === "string" ? input.hint : void 0;
-    const inputHint = hintRaw && hintRaw.trim() ? hintRaw.trim().slice(0, 120) : void 0;
+    effortChoices.push({
+      id,
+      ...typeof effort.label === "string" ? { name: effort.label } : typeof effort.name === "string" ? { name: effort.name } : {}
+    });
+  }
+  const hasEffortAxis = result.some((axis) => ["thought_level", "effort", "reasoning_effort"].includes(axis.category));
+  if (includeLaunchEffort && effortChoices.length > 0 && !hasEffortAxis) {
+    const currentEffort = typeof modelMeta?.reasoningEffort === "string" ? modelMeta.reasoningEffort : efforts.find((entry) => entry && typeof entry === "object" && entry.default)?.value;
     result.push({
-      name: rawName,
-      ...description ? { description } : {},
-      ...inputHint ? { inputHint } : {}
+      id: GROK_LAUNCH_EFFORT_AXIS_ID,
+      category: "reasoning_effort",
+      ...typeof currentEffort === "string" ? { currentValue: currentEffort } : {},
+      options: effortChoices
     });
-    if (result.length >= 200)
-      break;
   }
   return result;
 }
-function agentMessageChunkText(update) {
-  if (update.sessionUpdate !== "agent_message_chunk")
-    return "";
-  const content = update.content;
-  if (content?.type === "text")
-    return content.text ?? "";
-  if (typeof update.content === "string")
-    return update.content;
-  return "";
-}
-var CHUNK_CONTINUES_PREVIOUS_WORD = /^[\s'\u2018\u2019\u02bc.,!?;:%)\]}-]/;
-function continuesPreviousWord(current, delta) {
-  if (/\s$/.test(current))
-    return false;
-  return CHUNK_CONTINUES_PREVIOUS_WORD.test(delta);
-}
-var PI_ACP_HARNESS = /(^|[/\\])pi-acp(?:\.[a-z]+)?$/i;
-function isPiAcpHarness(agentLabel) {
-  return Boolean(agentLabel && PI_ACP_HARNESS.test(agentLabel));
+function filterAllowedModelConfigOptions(options) {
+  return options.filter((option) => isAllowedAgentModelConfigCategory(option.category));
 }
-function normalizeStreamDelta(text2, _agentLabel) {
-  return text2;
+var PROVIDER_CREDENTIAL_ENV_HINTS = {
+  openai: ["OPENAI_API_KEY", "OPENAI_COMPAT_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"],
+  google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  deepseek: ["DEEPSEEK_API_KEY"],
+  xai: ["XAI_API_KEY"],
+  cohere: ["COHERE_API_KEY"],
+  together: ["TOGETHER_API_KEY"],
+  fireworks: ["FIREWORKS_API_KEY"]
+};
+function credentialedProviders(env) {
+  const held = /* @__PURE__ */ new Set();
+  for (const [provider, names] of Object.entries(PROVIDER_CREDENTIAL_ENV_HINTS)) {
+    if (names.some((name) => Boolean(env[name]?.trim())))
+      held.add(provider);
+  }
+  for (const provider of credentialedPiCustomProviders(env))
+    held.add(provider);
+  return held;
 }
-function agentMessageRuns(updates, agentLabel) {
-  const runs = [];
-  let current = "";
-  let lastWasText = false;
-  for (const u4 of updates) {
-    const delta = normalizeStreamDelta(agentMessageChunkText(u4.update), agentLabel);
-    if (!delta) {
-      lastWasText = false;
-      continue;
+function credentialedPiCustomProviders(env) {
+  const agentDir = env.PI_CODING_AGENT_DIR?.trim() ? resolve4(env.PI_CODING_AGENT_DIR) : env.HOME?.trim() ? resolve4(env.HOME, ".pi/agent") : void 0;
+  const held = /* @__PURE__ */ new Set();
+  if (!agentDir)
+    return held;
+  const path = resolve4(agentDir, "models.json");
+  try {
+    const stats = lstatSync2(path);
+    if (!stats.isFile() || stats.isSymbolicLink() || stats.nlink !== 1 || stats.size > 1048576) {
+      return held;
     }
-    if (!lastWasText && current && !continuesPreviousWord(current, delta)) {
-      runs.push(current);
-      current = "";
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const providers = parsed.providers;
+    const remember = (name, config) => {
+      if (typeof name !== "string" || !name.trim() || !config || typeof config !== "object")
+        return;
+      const apiKey = config.apiKey;
+      if (typeof apiKey === "string" && apiKey.trim())
+        held.add(name.trim());
+    };
+    if (Array.isArray(providers)) {
+      for (const provider of providers) {
+        const record3 = provider;
+        remember(record3?.name ?? record3?.id, record3);
+      }
+    } else if (providers && typeof providers === "object") {
+      for (const [name, config] of Object.entries(providers)) {
+        remember(name, config);
+      }
     }
-    current += delta;
-    lastWasText = true;
+  } catch {
   }
-  if (current)
-    runs.push(current);
-  const seen = /* @__PURE__ */ new Set();
-  return runs.filter((run2) => {
-    if (seen.has(run2))
-      return false;
-    seen.add(run2);
-    return true;
+  return held;
+}
+function filterModelOptionsByCredentials(options, env) {
+  const held = credentialedProviders(env);
+  return options.map((option) => {
+    if (option.category !== "model")
+      return option;
+    return {
+      ...option,
+      options: option.options.filter((choice) => {
+        const slash = choice.id.indexOf("/");
+        if (slash < 0)
+          return true;
+        return held.has(choice.id.slice(0, slash));
+      })
+    };
   });
 }
-var RETRY_NARRATION_FRAGMENTS = [
-  // `Retrying (attempt 2/3, waiting 4s)` — the pi/ox-alpha shape.
-  /retrying\s*\((?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?\)/gi,
-  // A bare `(attempt 2/3...)` or `[attempt 2/3]` qualifier on its own.
-  /[([](?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?[))]\s*/gi,
-  // Standalone narration words with their optional trailing ellipsis.
-  /retrying\s*\.{0,3}/gi,
-  /retried\s*\.{0,3}/gi,
-  /retry\s+finished,?\s*/gi,
-  /retry\s+failed,?\s*/gi,
-  /resuming\.?/gi,
-  /waiting\s+\d+(?:\.\d+)?s/gi
-];
-function isPureRetryNarration(text2) {
-  const trimmed = text2.trim();
-  if (!trimmed)
-    return false;
-  let rest = trimmed;
-  for (const fragment of RETRY_NARRATION_FRAGMENTS) {
-    rest = rest.replace(fragment, "");
+var DisallowedModelConfigOptionError = class extends Error {
+  constructor(configId) {
+    super(`model config option "${configId}" is not in the allow-listed catalog`);
+    this.name = "DisallowedModelConfigOptionError";
   }
-  return !/[\w]/.test(rest);
-}
-function finalAgentMessageText(updates, agentLabel) {
-  const last = agentMessageRuns(updates, agentLabel).at(-1);
-  if (!last || isPureRetryNarration(last))
-    return "";
-  return last;
-}
-function describeEmptyTurn(result, agentLabel) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const { update } of result.updates) {
-    const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "unknown";
-    if (kind === "session_info_update" || kind === "available_commands_update")
-      continue;
-    counts.set(kind, (counts.get(kind) ?? 0) + 1);
+};
+var ModelSelectionUnavailableError = class extends Error {
+  label;
+  value;
+  reason;
+  guidance;
+  constructor(input) {
+    const recovery = input.guidance ? ` ${input.guidance}` : " Choose one of the values in the live harness catalog.";
+    super(`${input.label} "${input.value}" is unavailable.${recovery}`);
+    this.name = "ModelSelectionUnavailableError";
+    this.label = input.label;
+    this.value = input.value;
+    this.reason = input.reason;
+    this.guidance = input.guidance;
   }
-  const stream = counts.size ? `the stream carried only ${[...counts].map(([kind, count]) => `${kind}\xD7${count}`).join(", ")}` : "the stream carried no content updates";
-  const lastRun = agentMessageRuns(result.updates, agentLabel).at(-1);
-  const narration = lastRun && isPureRetryNarration(lastRun) ? `; the last message was retry narration "${lastRun.trim().slice(0, 80)}"` : "";
-  return `harness ended the turn (${result.stopReason}) with no answer text; ${stream}${narration}`;
+};
+function withEffectiveCurrentValues(options, selection) {
+  if (!selection || !selection.model && !selection.effort)
+    return options;
+  return options.map((option) => {
+    const target = modelSelectionTargets(selection).find((entry) => entry.categories.includes(option.category));
+    if (!target?.value || option.currentValue === target.value)
+      return option;
+    return { ...option, currentValue: target.value };
+  });
 }
-function updateText(update) {
-  const content = update.content;
-  if (typeof content === "string")
-    return content;
-  return content?.type === "text" ? content.text ?? "" : "";
+function modelSelectionTargets(selection) {
+  return [
+    { categories: ["model"], label: "model", value: selection.model },
+    {
+      categories: ["thought_level", "effort", "reasoning_effort"],
+      label: "effort",
+      value: selection.effort
+    }
+  ];
 }
-var THOUGHT_UPDATE_TYPES = /* @__PURE__ */ new Set([
-  "agent_thought_chunk",
-  "agent_thought",
-  "reasoning",
-  "reasoning_chunk",
-  "thinking",
-  "thinking_chunk",
-  "analysis",
-  "analysis_chunk",
-  "progress",
-  "progress_update"
-]);
-function agentStreamSnapshot(updates, agentLabel) {
-  const completedMessages = [];
-  let messageText2 = "";
-  let lastWasMessage = false;
-  let thoughtText2 = "";
-  let thoughtRunOpen = false;
-  for (const { update } of updates) {
-    const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "";
-    if (kind === "agent_message_chunk") {
-      const delta = normalizeStreamDelta(agentMessageChunkText(update), agentLabel);
-      if (!delta)
-        continue;
-      if (!lastWasMessage && messageText2 && !/\s$/.test(messageText2) && !CHUNK_CONTINUES_PREVIOUS_WORD.test(delta)) {
-        if (!completedMessages.includes(messageText2))
-          completedMessages.push(messageText2);
-        messageText2 = "";
-      }
-      messageText2 += delta;
-      lastWasMessage = true;
-      thoughtRunOpen = false;
+function assertModelConfigAxisAllowed(configId, advertisedOptions) {
+  const axis = advertisedOptions.find((option) => option.id === configId);
+  if (!axis || !isAllowedAgentModelConfigCategory(axis.category)) {
+    throw new DisallowedModelConfigOptionError(configId);
+  }
+}
+async function applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, advertisedOptions, selection) {
+  let currentOptions = advertisedOptions;
+  for (const target of modelSelectionTargets(selection)) {
+    if (!target.value)
       continue;
+    const axis = currentOptions.find((option) => target.categories.includes(option.category));
+    if (!axis)
+      continue;
+    assertModelConfigAxisAllowed(axis.id, currentOptions);
+    if (!axis.options.some((choice) => choice.id === target.value)) {
+      throw new ModelSelectionUnavailableError({
+        label: target.label,
+        value: target.value,
+        reason: "not-advertised"
+      });
     }
-    if (lastWasMessage && messageText2) {
-      if (!completedMessages.includes(messageText2))
-        completedMessages.push(messageText2);
-      messageText2 = "";
-    }
-    lastWasMessage = false;
-    if (THOUGHT_UPDATE_TYPES.has(kind)) {
-      const delta = normalizeStreamDelta(updateText(update), agentLabel);
-      if (!delta)
-        continue;
-      if (!thoughtRunOpen)
-        thoughtText2 = "";
-      thoughtText2 += delta;
-      thoughtRunOpen = true;
-    } else {
-      thoughtRunOpen = false;
+    try {
+      if (axis.id === GROK_SESSION_MODEL_AXIS_ID) {
+        if (!client.setModel)
+          throw new Error("ACP client does not support session/set_model");
+        await client.setModel(sessionId, target.value);
+      } else if (axis.id === GROK_LAUNCH_EFFORT_AXIS_ID) {
+        if (axis.currentValue !== target.value) {
+          throw new Error(`Grok started with reasoning effort "${axis.currentValue ?? "unknown"}", not "${target.value}"`);
+        }
+      } else {
+        const updated = await client.setConfigOption(sessionId, axis.id, target.value);
+        const refreshed = filterAllowedModelConfigOptions(parseAdvertisedConfigOptions(updated, selection.model));
+        if (refreshed.length > 0)
+          currentOptions = refreshed;
+      }
+    } catch (error) {
+      throw new ModelSelectionUnavailableError({
+        label: target.label,
+        value: target.value,
+        reason: "provider-refused",
+        guidance: error instanceof Error ? error.message : String(error)
+      });
     }
   }
-  return {
-    messageText: messageText2,
-    ...thoughtText2 || completedMessages.length ? { thoughtText: thoughtText2 || completedMessages.at(-1) } : {}
-  };
+  return currentOptions;
 }
-function toolCallEntries(updates) {
-  const calls = /* @__PURE__ */ new Map();
-  let anonymous = 0;
-  let activeAnonymous;
-  for (const { update } of updates) {
-    const sessionUpdate = update.sessionUpdate;
-    if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update" && sessionUpdate !== "tool_result") {
-      continue;
+async function applyAgentModelSelection(client, sessionId, advertisedOptions, selection) {
+  await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, advertisedOptions, selection);
+}
+
+// apps/body/dist/model-catalog.js
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve as resolve5 } from "node:path";
+
+// apps/body/dist/acp.js
+import { spawn as spawn5 } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+// apps/body/dist/harness-capabilities.js
+function harnessHonorsSessionSystemPrompt(agentCommand) {
+  return Boolean(agentCommand && /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i.test(agentCommand));
+}
+var GROK_WARM_SESSION_IDLE_MS = 30 * 6e4;
+function cornerAutonomyModeCandidates(agentCommand) {
+  if (agentCommand && /(^|[/\\])codex-acp(\.[a-z]+)?$/i.test(agentCommand)) {
+    return ["agent-full-access"];
+  }
+  if (agentCommand && /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i.test(agentCommand)) {
+    return ["bypassPermissions"];
+  }
+  if (agentCommand && /(^|[/\\])grok(\.[a-z]+)?$/i.test(agentCommand))
+    return [];
+  if (agentCommand && /(^|[/\\])pi-acp(\.[a-z]+)?$/i.test(agentCommand))
+    return [];
+  return ["agent", "edit", "code"];
+}
+function roomModeCandidates(agentCommand, options = {}) {
+  if (options.osSandbox && agentCommand && /(^|[/\\])codex-acp(\.[a-z]+)?$/i.test(agentCommand)) {
+    return ["agent-full-access"];
+  }
+  return ["read-only", "readonly"];
+}
+
+// apps/body/dist/harness-tool-scope.js
+var CLAUDE_TOOL_SCOPE_SETTINGS = { disableClaudeAiConnectors: true };
+var CLAUDE_PROFILE = {
+  // `settingSources: ['user']` admits the sanitized user MCP copy
+  // while rejecting repository/local/plugin MCP. `strictMcpConfig` cannot be
+  // used because it would reject the user copy too. Account-bound claude.ai
+  // cloud connectors remain off independently.
+  enforcement: "config-isolated",
+  note: "claude-agent-acp forwards _meta.claudeCode.options to the Claude Agent SDK; user-only settingSources loads MCP from the isolated CLAUDE_CONFIG_DIR without repository/local settings, while disableClaudeAiConnectors keeps account-bound connectors off",
+  sessionMeta: {
+    claudeCode: {
+      options: {
+        // Only the sanitized user config in the isolated CLAUDE_CONFIG_DIR;
+        // never a repository's .mcp.json, local settings, or plugins.
+        settingSources: ["user"],
+        // Account-bound claude.ai cloud connectors are not fetched at all.
+        settings: CLAUDE_TOOL_SCOPE_SETTINGS
+      }
     }
-    const id = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
-    if (id)
-      activeAnonymous = void 0;
-    if (!id && (sessionUpdate === "tool_call" || !activeAnonymous)) {
-      activeAnonymous = `anonymous-${anonymous++}`;
+  },
+  metaSystemPrompt: true
+};
+var PROFILES = [
+  { match: /(^|[/\\])claude-(agent|code)-acp(\.[a-z]+)?$/i, profile: CLAUDE_PROFILE },
+  {
+    match: /(^|[/\\])codex-acp(\.[a-z]+)?$/i,
+    profile: {
+      enforcement: "config-isolated",
+      note: "codex-acp merges the session's MCP servers into $CODEX_HOME/config.toml's own [mcp_servers] instead of replacing them, so only an isolated CODEX_HOME scopes the session; the ChatGPT account's codex_apps connectors survive either way"
+    }
+  },
+  {
+    match: /(^|[/\\])pi-acp(\.[a-z]+)?$/i,
+    profile: {
+      enforcement: "config-isolated",
+      note: "pi-acp 0.0.33 still stores session/new mcpServers and never reads them; pi 0.85.1 itself has no MCP client, while optional pi-mcp-adapter reads $PI_CODING_AGENT_DIR/mcp.json and isolated homes exclude the settings.json that would load it"
+    }
+  },
+  {
+    match: /(^|[/\\])grok(\.[a-z]+)?$/i,
+    profile: {
+      enforcement: "config-isolated",
+      note: "grok loads the operator's own ~/.grok MCP servers even when session/new passes an empty mcpServers list (measured live), so only an isolated GROK_HOME scopes the session; no account-bound connector surface was found"
+    }
+  },
+  {
+    match: /(^|[/\\])buzz-agent(\.[a-z]+)?$/i,
+    profile: {
+      enforcement: "allowlisted",
+      note: "buzz-agent mounts only the MCP servers the daemon passes; it has no operator-global tool config"
+    }
+  },
+  {
+    match: CURSOR_HARNESS_COMMAND,
+    profile: {
+      enforcement: "config-isolated",
+      note: "cursor-acp-bridge writes session/new mcpServers into the isolated CURSOR_HOME mcp.json and the isolated $HOME/.cursor/mcp.json cursor-agent loads; it never writes the operator ~/.cursor"
     }
-    const key = id ?? activeAnonymous;
-    const previous = calls.get(key);
-    calls.set(key, {
-      ...previous,
-      id: key,
-      ...typeof update.title === "string" ? { title: update.title } : {},
-      ...typeof update.kind === "string" ? { kind: update.kind } : {},
-      ...typeof update.status === "string" ? { status: update.status } : {},
-      ...sessionUpdate === "tool_result" ? { resultReceived: true } : {},
-      ..."rawInput" in update ? { rawInput: update.rawInput } : {},
-      ..."content" in update ? { content: update.content } : {},
-      ..."rawOutput" in update ? { rawOutput: update.rawOutput } : {},
-      ..."locations" in update ? { locations: update.locations } : {}
-    });
-    if (!id && sessionUpdate === "tool_result")
-      activeAnonymous = void 0;
   }
-  return [...calls.values()];
+];
+function sessionToolScopeMeta(agentCommand) {
+  const meta = matchProfile(agentCommand)?.sessionMeta;
+  return meta ? JSON.parse(JSON.stringify(meta)) : void 0;
 }
-var AcpClient = class extends EventEmitter {
-  child = null;
-  buf = "";
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  activeRunIds = /* @__PURE__ */ new Map();
-  activePromptSessions = /* @__PURE__ */ new Set();
-  /** Tool metadata arrives in session/update just before a sparse permission request. */
-  toolCallMetadata = /* @__PURE__ */ new Map();
-  /** Latest `available_commands_update` per session, keyed by sessionId. */
-  sessionCommands = /* @__PURE__ */ new Map();
-  supportsStandardSteering = false;
-  supportsSessionLoading = false;
-  supportsImagePrompts = false;
-  alive = false;
-  /** Bounded tail of recent stderr, so a spawn/exit failure's rejection text
-   *  carries the real reason (e.g. a harness's own "missing API key" notice)
-   *  instead of just the bare exit code, in the daemon's log. */
-  stderrTail = "";
-  agentEnv;
-  agentCommand;
-  agentLabel;
-  agentArgs;
-  agentCwd;
-  inheritProcessEnv;
-  autoApprove;
-  osSandbox;
-  permissionHandler;
-  permissionAllowlist;
-  commandsHandler;
-  constructor(opts) {
-    super();
-    const command = opts.agentCommand ?? opts.agentBinary;
-    if (!command)
-      throw new Error("ACP agent command is required");
-    this.agentCommand = command;
-    this.agentLabel = opts.agentLabel ?? command;
-    this.agentArgs = [...opts.agentArgs ?? []];
-    this.agentEnv = opts.agentEnv;
-    if (opts.agentCwd)
-      this.agentCwd = opts.agentCwd;
-    this.inheritProcessEnv = opts.inheritProcessEnv ?? process.env.BUZZY_BODY_AGENT_ENV_INHERIT === "1";
-    this.autoApprove = opts.autoApprovePermissions ?? true;
-    this.osSandbox = opts.osSandbox ?? false;
-    this.permissionHandler = opts.permissionHandler;
-    this.permissionAllowlist = opts.permissionAllowlist;
-    this.commandsHandler = opts.onCommands;
+function harnessReadsMetaSystemPrompt(agentCommand) {
+  return matchProfile(agentCommand)?.metaSystemPrompt === true;
+}
+function matchProfile(agentCommand) {
+  if (!agentCommand)
+    return void 0;
+  for (const { match, profile } of PROFILES) {
+    if (match.test(agentCommand))
+      return profile;
   }
-  async start(timeoutMs = 6e4) {
-    if (this.alive)
-      return;
-    this.child = spawn4(this.agentCommand, this.agentArgs, {
-      // agentEnv is the child's whole environment: buildAgentEnv's allowlist is
-      // a real boundary, not a decorative one layered over a full inherit.
-      env: this.inheritProcessEnv ? { ...process.env, ...this.agentEnv } : this.agentEnv,
-      ...this.agentCwd ? { cwd: this.agentCwd } : {},
-      // The harness and every tool it spawns share a disposable process
-      // group. A hard turn deadline can therefore retire the whole tree,
-      // never just the ACP parent while a shell/compiler keeps running.
-      detached: process.platform !== "win32",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.alive = true;
-    this.stderrTail = "";
-    this.child.stderr.setEncoding("utf8");
-    this.child.stderr.on("data", (chunk) => {
-      this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_TAIL_MAX_CHARS2);
-      this.emit("stderr", chunk);
-    });
-    this.child.stdout.setEncoding("utf8");
-    this.child.stdout.on("data", (chunk) => this.onData(chunk));
-    this.child.on("exit", (code, signal) => {
-      this.alive = false;
-      const meaningful = flattenHarnessCause(this.stderrTail);
-      const stderrSuffix = meaningful ? `: ${meaningful}` : "";
-      for (const [, p] of this.pending) {
-        this.clearTimer(p);
-        p.reject(new Error(`ACP agent ${this.agentLabel} exited code=${code} signal=${signal}${stderrSuffix}`));
-      }
-      this.pending.clear();
-      this.activeRunIds.clear();
-      this.activePromptSessions.clear();
-      this.toolCallMetadata.clear();
-      this.sessionCommands.clear();
-      this.emit("exit", { code, signal });
-    });
-    this.child.on("error", (err) => {
-      this.alive = false;
-      for (const [, p] of this.pending) {
-        clearTimeout(p.timer);
-        p.reject(err);
-      }
-      this.pending.clear();
-      if (this.listenerCount("error") > 0)
-        this.emit("error", err);
-    });
-    const initResult = await this.request("initialize", {
-      protocolVersion: 1,
-      clientCapabilities: {}
-    }, timeoutMs);
-    const initMeta = initResult._meta;
-    const steering = initMeta?.steering;
-    this.supportsStandardSteering = steering?.supported === true;
-    const agentCapabilities = initResult.agentCapabilities;
-    this.supportsSessionLoading = agentCapabilities?.loadSession === true;
-    this.supportsImagePrompts = agentCapabilities?.promptCapabilities?.image === true;
-    this.emit("initialized", initResult);
-    if (!isPiAcpHarness(this.agentLabel))
-      this.notify("notifications/initialized", {});
+  return void 0;
+}
+
+// apps/body/dist/acp.js
+var STDERR_TAIL_MAX_CHARS2 = 2e3;
+function braceDelta(line) {
+  let delta = 0;
+  for (const char of line) {
+    if (char === "{")
+      delta += 1;
+    else if (char === "}")
+      delta -= 1;
   }
-  async stop() {
-    if (!this.alive)
-      return;
-    const child = this.child;
-    if (!child)
-      return;
-    try {
-      if (this.child?.stdin.writable) {
-        this.notify("shutdown", {});
-      }
-    } catch {
+  return delta;
+}
+function meaningfulHarnessStderr(tail) {
+  const lines = tail.split(/\r?\n/);
+  const kept = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!/error handling notification/i.test(line)) {
+      kept.push(line);
+      continue;
     }
-    await new Promise((r2) => setTimeout(r2, 300));
-    try {
-      killChildProcessGroup(child, "SIGTERM");
-    } catch {
+    const block2 = [line];
+    let depth = braceDelta(line);
+    if (depth === 0 && lines[index + 1]?.trimStart().startsWith("{")) {
+      index += 1;
+      block2.push(lines[index]);
+      depth = braceDelta(lines[index]);
     }
-    await new Promise((r2) => setTimeout(r2, 500));
-    try {
-      killChildProcessGroup(child, "SIGKILL");
-    } catch {
+    while (depth > 0 && index + 1 < lines.length) {
+      index += 1;
+      block2.push(lines[index]);
+      depth += braceDelta(lines[index]);
     }
-    this.child = null;
-    this.alive = false;
-    this.activeRunIds.clear();
-    this.activePromptSessions.clear();
-    this.toolCallMetadata.clear();
-  }
-  get isAlive() {
-    return this.alive;
-  }
-  /** Host pid of the harness wrapper (bwrap when enabled). */
-  processPid() {
-    return this.child?.pid;
+    if (!/notifications\/initialized/.test(block2.join("\n")))
+      kept.push(...block2);
   }
-  /** The latest command list this harness advertised for a session, if any. */
-  sessionCommandsFor(sessionId) {
-    return this.sessionCommands.get(sessionId) ?? [];
+  return kept.join("\n").trim();
+}
+function flattenHarnessCause(tail) {
+  return meaningfulHarnessStderr(tail).replace(/\s+/g, " ").trim();
+}
+var AcpRequestTimeoutError = class extends Error {
+  method;
+  timeoutMs;
+  inactivity;
+  code = "ACP_REQUEST_TIMEOUT";
+  constructor(method, timeoutMs, stderrTail = "", inactivity = false, detail = "") {
+    const meaningful = flattenHarnessCause(stderrTail);
+    const suffix = meaningful ? `; harness stderr: ${meaningful}` : "";
+    super(`ACP ${method} timed out after ${timeoutMs}ms${inactivity ? " of inactivity" : ""}${detail ? ` (${detail})` : ""}${suffix}`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+    this.inactivity = inactivity;
+    this.name = "AcpRequestTimeoutError";
   }
-  /** Whether this live ACP process advertised the stable `session/load` method. */
-  canLoadSession() {
-    return this.supportsSessionLoading;
+};
+function killChildProcessGroup(child, signal) {
+  if (!child.pid)
+    return;
+  try {
+    if (process.platform === "win32")
+      child.kill(signal);
+    else
+      process.kill(-child.pid, signal);
+  } catch (error) {
+    if (error.code !== "ESRCH")
+      throw error;
   }
-  /** Whether this live ACP process accepts `image` prompt blocks (`promptCapabilities.image`). */
-  canPromptWithImages() {
-    return this.supportsImagePrompts;
+}
+function promptPayloadNote(prompt) {
+  if (typeof prompt === "string")
+    return "";
+  const images = prompt.filter((block2) => block2.type === "image");
+  if (!images.length)
+    return "";
+  const bytes = images.reduce((total, block2) => total + Math.floor(block2.data.length * 3 / 4), 0);
+  return `prompt carried ${images.length} inline image${images.length === 1 ? "" : "s"}, ${Math.round(bytes / 1024)} KB`;
+}
+function parseAvailableCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const record3 = entry;
+    const rawName = typeof record3.name === "string" ? record3.name.trim().replace(/^\/+/, "") : "";
+    if (!rawName || rawName.length > 80 || seen.has(rawName))
+      continue;
+    seen.add(rawName);
+    const description = typeof record3.description === "string" && record3.description.trim() ? record3.description.trim().slice(0, 300) : void 0;
+    const input = record3.input;
+    const hintRaw = input && typeof input.hint === "string" ? input.hint : void 0;
+    const inputHint = hintRaw && hintRaw.trim() ? hintRaw.trim().slice(0, 120) : void 0;
+    result.push({
+      name: rawName,
+      ...description ? { description } : {},
+      ...inputHint ? { inputHint } : {}
+    });
+    if (result.length >= 200)
+      break;
   }
-  async sessionNew(opts) {
-    const params = {
-      cwd: opts.cwd,
-      mcpServers: (opts.mcpServers ?? []).map((s) => ({
-        name: s.name,
-        command: s.command,
-        args: s.args ?? [],
-        env: s.env ?? []
-      }))
-    };
-    if (opts.systemPrompt)
-      params.systemPrompt = opts.systemPrompt;
-    const meta = {
-      ...sessionToolScopeMeta(this.agentLabel) ?? {}
-    };
-    if (opts.systemPrompt && harnessReadsMetaSystemPrompt(this.agentLabel)) {
-      meta.systemPrompt = { append: opts.systemPrompt };
-    }
-    if (Object.keys(meta).length > 0)
-      params._meta = meta;
-    const raw = await this.request("session/new", params, opts.timeoutMs ?? 6e4);
-    const sessionId = raw.sessionId;
-    if (!sessionId)
-      throw new Error("session/new missing sessionId");
-    await this.applySessionMode(sessionId, raw, opts.mode);
-    return { sessionId, raw };
-  }
-  /**
-   * Reopen a provider-persisted logical conversation in this new ACP process.
-   * Unlike `session/new`, load accepts no system prompt: the harness restores
-   * its own conversation and instructions instead of receiving transcript
-   * text from Body again.
-   */
-  async sessionLoad(opts) {
-    if (!this.supportsSessionLoading) {
-      throw new Error("ACP agent does not advertise session/load");
-    }
-    const params = {
-      sessionId: opts.sessionId,
-      cwd: opts.cwd,
-      mcpServers: (opts.mcpServers ?? []).map((server) => ({
-        name: server.name,
-        command: server.command,
-        args: server.args ?? [],
-        env: server.env ?? []
-      }))
-    };
-    const meta = sessionToolScopeMeta(this.agentLabel);
-    if (meta)
-      params._meta = meta;
-    const result = await this.request("session/load", params);
-    const raw = result && typeof result === "object" ? result : {};
-    await this.applySessionMode(opts.sessionId, raw, opts.mode);
-    return { sessionId: opts.sessionId, raw };
-  }
-  async applySessionMode(sessionId, raw, mode) {
-    if (!mode)
-      return;
-    const modes = raw.modes;
-    const candidates = mode === "readonly" ? roomModeCandidates(this.agentLabel, { osSandbox: this.osSandbox }) : cornerAutonomyModeCandidates(this.agentLabel);
-    const target = modes?.availableModes?.find((candidate) => candidate.id && candidates.includes(candidate.id))?.id;
-    if (!target || modes?.currentModeId === target)
-      return;
-    await this.request("session/set_mode", { sessionId, modeId: target });
-  }
-  /**
-   * Run one prompt turn. `timeoutMs` is an idle window, not a hard cap on
-   * turn length: every `session/update` for this session (message chunk,
-   * tool call, or otherwise) re-arms it, so an actively-working agent can
-   * run indefinitely while a genuinely wedged one (zero activity for
-   * `timeoutMs`) still gets cancelled. `onChunk` is the ACP-boundary
-   * streaming hook: called for every incremental `agent_message_chunk`
-   * delta as it arrives, so a caller can project live text without waiting
-   * for the turn to finish. A harness that only emits a final message
-   * (never chunks) simply never invokes it — `agentText` is unaffected
-   * either way. `onActivity`, when given, fires on every `session/update`
-   * regardless of kind (the same trigger that re-arms the idle timer above),
-   * so a caller can drive its own shorter "still working" notice off the
-   * identical genuine-activity signal without duplicating the timeout logic.
-   * It receives the current lane snapshot; existing callbacks that ignore
-   * arguments remain valid.
-   */
-  async sessionPrompt(sessionId, text2, timeoutMs = 12e4, onChunk, onActivity, onToolCalls) {
-    const updates = [];
-    let promptRunId;
-    let requestId;
-    const onUpdate = (u4) => {
-      if (u4.sessionId !== sessionId)
-        return;
-      updates.push(u4);
-      promptRunId ??= this.activeRunIdFromUpdate(u4.update);
-      if (requestId !== void 0)
-        this.resetPendingIdleTimeout(requestId);
-      onActivity?.(agentStreamSnapshot(updates, this.agentLabel));
-      onToolCalls?.(toolCallEntries(updates));
-      if (onChunk) {
-        const delta = agentMessageChunkText(u4.update);
-        if (delta) {
-          const runs = agentMessageRuns(updates, this.agentLabel);
-          onChunk(delta, runs.join("\n\n"), runs.at(-1), runs);
-        }
-      }
-    };
-    this.on("session/update", onUpdate);
-    this.activePromptSessions.add(sessionId);
-    try {
-      const result = await this.request("session/prompt", {
-        sessionId,
-        prompt: typeof text2 === "string" ? [{ type: "text", text: text2 }] : [...text2]
-      }, timeoutMs, (id) => {
-        requestId = id;
-      }, promptPayloadNote(text2));
-      const agentText = finalAgentMessageText(updates, this.agentLabel);
-      const toolCalls = toolCallEntries(updates);
-      return {
-        stopReason: result?.stopReason ?? "end_turn",
-        updates,
-        agentText,
-        toolCalls
-      };
-    } finally {
-      this.activePromptSessions.delete(sessionId);
-      if (promptRunId && this.activeRunIds.get(sessionId) === promptRunId) {
-        this.activeRunIds.delete(sessionId);
-      }
-      this.off("session/update", onUpdate);
-    }
-  }
-  /**
-   * Inject follow-up input into the prompt currently running for this session.
-   * buzz-agent advertises the target run through ACP session metadata; binding
-   * the request to that id prevents a late message from steering a newer turn.
-   */
-  async sessionSteer(sessionId, text2, timeoutMs = 6e4) {
-    if (this.supportsStandardSteering) {
-      const raw2 = await this.request("_session/steering", {
-        sessionId,
-        prompt: [{ type: "text", text: text2 }]
-      }, timeoutMs);
-      if (!raw2.outcome || raw2.outcome === "failed") {
-        throw new Error("ACP session steering failed");
-      }
-      return {
-        runId: this.activeRunId(sessionId) ?? `session:${sessionId}`,
-        messageId: raw2.outcome
-      };
+  return result;
+}
+function agentMessageChunkText(update) {
+  if (update.sessionUpdate !== "agent_message_chunk")
+    return "";
+  const content = update.content;
+  if (content?.type === "text")
+    return content.text ?? "";
+  if (typeof update.content === "string")
+    return update.content;
+  return "";
+}
+var CHUNK_CONTINUES_PREVIOUS_WORD = /^[\s'\u2018\u2019\u02bc.,!?;:%)\]}-]/;
+function continuesPreviousWord(current, delta) {
+  if (/\s$/.test(current))
+    return false;
+  return CHUNK_CONTINUES_PREVIOUS_WORD.test(delta);
+}
+var PI_ACP_HARNESS = /(^|[/\\])pi-acp(?:\.[a-z]+)?$/i;
+function isPiAcpHarness(agentLabel) {
+  return Boolean(agentLabel && PI_ACP_HARNESS.test(agentLabel));
+}
+function normalizeStreamDelta(text2, _agentLabel) {
+  return text2;
+}
+function agentMessageRuns(updates, agentLabel) {
+  const runs = [];
+  let current = "";
+  let lastWasText = false;
+  for (const u4 of updates) {
+    const delta = normalizeStreamDelta(agentMessageChunkText(u4.update), agentLabel);
+    if (!delta) {
+      lastWasText = false;
+      continue;
     }
-    const expectedRunId = await this.waitForActiveRun(sessionId, Math.min(timeoutMs, 5e3));
-    const raw = await this.request("_goose/unstable/session/steer", {
-      sessionId,
-      prompt: [{ type: "text", text: text2 }],
-      expectedRunId
-    }, timeoutMs);
-    if (!raw.runId || !raw.messageId) {
-      throw new Error("ACP session steer response missing runId or messageId");
+    if (!lastWasText && current && !continuesPreviousWord(current, delta)) {
+      runs.push(current);
+      current = "";
     }
-    return { runId: raw.runId, messageId: raw.messageId };
-  }
-  /** Active ACP run for a session, if the agent has advertised one. */
-  activeRunId(sessionId) {
-    return this.activeRunIds.get(sessionId) ?? (this.activePromptSessions.has(sessionId) ? `session:${sessionId}` : void 0);
-  }
-  sessionCancel(sessionId) {
-    this.notify("session/cancel", { sessionId });
-  }
-  /**
-   * The portable model/effort setter, confirmed round-tripping on pi/codex/
-   * claude (report `data/buzzy-multiagent-runtimes/report.md` §3.2). The
-   * param is `configId`, not `optionId`. Harnesses that advertise this shape
-   * must use it; `session/set_model` is reserved for the distinct standard
-   * `session/new.models` shape. Returns the runtime's updated `configOptions`.
-   * Callers must validate `configId`/`value` against the
-   * allow-listed catalog before calling this — see
-   * `apps/body/src/model-config.ts`'s `assertModelConfigOptionAllowed`; this
-   * method performs no policy checks of its own.
-   */
-  async setConfigOption(sessionId, configId, value) {
-    return this.request("session/set_config_option", { sessionId, configId, value });
-  }
-  /**
-   * Standard ACP model setter used only when `session/new.models` supplied the
-   * corresponding safe model axis. Most Beeline harnesses use configOptions;
-   * Grok currently exposes models through this standard method instead.
-   */
-  async setModel(sessionId, modelId) {
-    return this.request("session/set_model", { sessionId, modelId });
+    current += delta;
+    lastWasText = true;
   }
-  clearTimer(p) {
-    if (p.timer) {
-      clearTimeout(p.timer);
-      p.timer = void 0;
-    }
+  if (current)
+    runs.push(current);
+  const seen = /* @__PURE__ */ new Set();
+  return runs.filter((run2) => {
+    if (seen.has(run2))
+      return false;
+    seen.add(run2);
+    return true;
+  });
+}
+var RETRY_NARRATION_FRAGMENTS = [
+  // `Retrying (attempt 2/3, waiting 4s)` — the pi/ox-alpha shape.
+  /retrying\s*\((?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?\)/gi,
+  // A bare `(attempt 2/3...)` or `[attempt 2/3]` qualifier on its own.
+  /[([](?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?[))]\s*/gi,
+  // Standalone narration words with their optional trailing ellipsis.
+  /retrying\s*\.{0,3}/gi,
+  /retried\s*\.{0,3}/gi,
+  /retry\s+finished,?\s*/gi,
+  /retry\s+failed,?\s*/gi,
+  /resuming\.?/gi,
+  /waiting\s+\d+(?:\.\d+)?s/gi
+];
+function isPureRetryNarration(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed)
+    return false;
+  let rest = trimmed;
+  for (const fragment of RETRY_NARRATION_FRAGMENTS) {
+    rest = rest.replace(fragment, "");
   }
-  /**
-   * Re-arm a pending request's idle timer from its full `idleTimeoutMs`,
-   * called on every ACP activity signal for that request (streamed text
-   * delta, session/update, tool call). A request only times out after this
-   * much wall-clock time with zero activity, not after a fixed deadline —
-   * so an actively-working turn can run indefinitely while a genuinely
-   * wedged one still gets caught.
-   */
-  resetPendingIdleTimeout(id) {
-    const p = this.pending.get(id);
-    if (!p || p.idleTimeoutMs === void 0)
-      return;
-    this.clearTimer(p);
-    const { idleTimeoutMs, method, reject, detail } = p;
-    p.timer = setTimeout(() => {
-      this.pending.delete(id);
-      reject(new AcpRequestTimeoutError(method ?? "request", idleTimeoutMs, this.stderrTail, true, detail ?? ""));
-    }, idleTimeoutMs);
+  return !/[\w]/.test(rest);
+}
+function finalAgentMessageText(updates, agentLabel) {
+  const last = agentMessageRuns(updates, agentLabel).at(-1);
+  if (!last || isPureRetryNarration(last))
+    return "";
+  return last;
+}
+function describeEmptyTurn(result, agentLabel) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { update } of result.updates) {
+    const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "unknown";
+    if (kind === "session_info_update" || kind === "available_commands_update")
+      continue;
+    counts.set(kind, (counts.get(kind) ?? 0) + 1);
   }
-  onData(chunk) {
-    this.buf += chunk;
-    let nl;
-    while ((nl = this.buf.indexOf("\n")) >= 0) {
-      const line = this.buf.slice(0, nl).trim();
-      this.buf = this.buf.slice(nl + 1);
-      if (!line)
-        continue;
-      let msg;
-      try {
-        msg = JSON.parse(line);
-      } catch {
+  const stream = counts.size ? `the stream carried only ${[...counts].map(([kind, count]) => `${kind}\xD7${count}`).join(", ")}` : "the stream carried no content updates";
+  const lastRun = agentMessageRuns(result.updates, agentLabel).at(-1);
+  const narration = lastRun && isPureRetryNarration(lastRun) ? `; the last message was retry narration "${lastRun.trim().slice(0, 80)}"` : "";
+  return `harness ended the turn (${result.stopReason}) with no answer text; ${stream}${narration}`;
+}
+function updateText(update) {
+  const content = update.content;
+  if (typeof content === "string")
+    return content;
+  return content?.type === "text" ? content.text ?? "" : "";
+}
+var THOUGHT_UPDATE_TYPES = /* @__PURE__ */ new Set([
+  "agent_thought_chunk",
+  "agent_thought",
+  "reasoning",
+  "reasoning_chunk",
+  "thinking",
+  "thinking_chunk",
+  "analysis",
+  "analysis_chunk",
+  "progress",
+  "progress_update"
+]);
+function agentStreamSnapshot(updates, agentLabel) {
+  const completedMessages = [];
+  let messageText2 = "";
+  let lastWasMessage = false;
+  let thoughtText2 = "";
+  let thoughtRunOpen = false;
+  for (const { update } of updates) {
+    const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "";
+    if (kind === "agent_message_chunk") {
+      const delta = normalizeStreamDelta(agentMessageChunkText(update), agentLabel);
+      if (!delta)
         continue;
+      if (!lastWasMessage && messageText2 && !/\s$/.test(messageText2) && !CHUNK_CONTINUES_PREVIOUS_WORD.test(delta)) {
+        if (!completedMessages.includes(messageText2))
+          completedMessages.push(messageText2);
+        messageText2 = "";
       }
-      this.handleMessage(msg);
+      messageText2 += delta;
+      lastWasMessage = true;
+      thoughtRunOpen = false;
+      continue;
     }
-  }
-  handleMessage(msg) {
-    const id = msg.id;
-    const method = msg.method;
-    if (id !== void 0 && !method) {
-      const n3 = Number(id);
-      const p = this.pending.get(n3);
-      if (!p)
-        return;
-      this.pending.delete(n3);
-      this.clearTimer(p);
-      if (msg.error) {
-        const err = msg.error;
-        const details = typeof err.data?.details === "string" && err.data.details.trim() ? err.data.details.replace(/\s+/g, " ").trim() : "";
-        const meaningful = flattenHarnessCause(this.stderrTail);
-        const extra = [details, meaningful ? `harness stderr: ${meaningful}` : ""].filter(Boolean).join("; ");
-        p.reject(new Error(`ACP error ${err.code}: ${err.message}${extra ? `; ${extra}` : ""}`));
-      } else {
-        p.resolve(msg.result);
-      }
-      return;
+    if (lastWasMessage && messageText2) {
+      if (!completedMessages.includes(messageText2))
+        completedMessages.push(messageText2);
+      messageText2 = "";
+    }
+    lastWasMessage = false;
+    if (THOUGHT_UPDATE_TYPES.has(kind)) {
+      const delta = normalizeStreamDelta(updateText(update), agentLabel);
+      if (!delta)
+        continue;
+      if (!thoughtRunOpen)
+        thoughtText2 = "";
+      thoughtText2 += delta;
+      thoughtRunOpen = true;
+    } else {
+      thoughtRunOpen = false;
     }
-    if (method && id !== void 0) {
-      if (method === "session/request_permission") {
-        void this.handlePermission(id, msg.params);
-        return;
-      }
-      this.write({ jsonrpc: "2.0", id, result: {} });
-      return;
+  }
+  return {
+    messageText: messageText2,
+    ...thoughtText2 || completedMessages.length ? { thoughtText: thoughtText2 || completedMessages.at(-1) } : {}
+  };
+}
+function toolCallEntries(updates) {
+  const calls = /* @__PURE__ */ new Map();
+  let anonymous = 0;
+  let activeAnonymous;
+  for (const { update } of updates) {
+    const sessionUpdate = update.sessionUpdate;
+    if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update" && sessionUpdate !== "tool_result") {
+      continue;
     }
-    if (method === "session/update") {
-      const params = msg.params;
-      if (params?.sessionId && params.update) {
-        if (params.update.sessionUpdate === "available_commands_update") {
-          const commands = parseAvailableCommands(params.update.availableCommands);
-          this.sessionCommands.set(params.sessionId, commands);
-          this.commandsHandler?.(commands);
-          this.emit("commands", { sessionId: params.sessionId, commands });
-        }
-        const toolCallId = params.update.toolCallId;
-        const sessionUpdate = params.update.sessionUpdate;
-        if (typeof toolCallId === "string" && (sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update")) {
-          const metadataKey = `${params.sessionId}\0${toolCallId}`;
-          const status = params.update.status;
-          if (status === "completed" || status === "failed") {
-            this.toolCallMetadata.delete(metadataKey);
-          } else {
-            const existing = this.toolCallMetadata.get(metadataKey);
-            this.toolCallMetadata.set(metadataKey, {
-              ...existing,
-              toolCallId,
-              ...typeof params.update.title === "string" ? { title: params.update.title } : {},
-              ...typeof params.update.kind === "string" ? { kind: params.update.kind } : {},
-              ..."rawInput" in params.update ? { rawInput: params.update.rawInput } : {},
-              // `content`/`locations` carry the touched file paths for adapters
-              // whose permission request omits them (codex-acp's file-change
-              // request has no rawInput at all) — the corner worktree guard in
-              // `session-sandbox.ts` reads them.
-              ..."content" in params.update ? { content: params.update.content } : {},
-              ..."locations" in params.update ? { locations: params.update.locations } : {}
-            });
-          }
-        }
-        const u4 = {
-          sessionId: params.sessionId,
-          update: params.update
-        };
-        const activeRunId = this.activeRunIdFromUpdate(params.update);
-        if (activeRunId)
-          this.activeRunIds.set(params.sessionId, activeRunId);
-        this.emit("session/update", u4);
-      }
-      return;
+    const id = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+    if (id)
+      activeAnonymous = void 0;
+    if (!id && (sessionUpdate === "tool_call" || !activeAnonymous)) {
+      activeAnonymous = `anonymous-${anonymous++}`;
     }
+    const key = id ?? activeAnonymous;
+    const previous = calls.get(key);
+    calls.set(key, {
+      ...previous,
+      id: key,
+      ...typeof update.title === "string" ? { title: update.title } : {},
+      ...typeof update.kind === "string" ? { kind: update.kind } : {},
+      ...typeof update.status === "string" ? { status: update.status } : {},
+      ...sessionUpdate === "tool_result" ? { resultReceived: true } : {},
+      ..."rawInput" in update ? { rawInput: update.rawInput } : {},
+      ..."content" in update ? { content: update.content } : {},
+      ..."rawOutput" in update ? { rawOutput: update.rawOutput } : {},
+      ..."locations" in update ? { locations: update.locations } : {}
+    });
+    if (!id && sessionUpdate === "tool_result")
+      activeAnonymous = void 0;
   }
-  activeRunIdFromUpdate(update) {
-    const meta = update._meta;
-    const goose = meta?.goose;
-    return typeof goose?.activeRunId === "string" && goose.activeRunId ? goose.activeRunId : void 0;
+  return [...calls.values()];
+}
+var AcpClient = class extends EventEmitter {
+  child = null;
+  buf = "";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  activeRunIds = /* @__PURE__ */ new Map();
+  activePromptSessions = /* @__PURE__ */ new Set();
+  /** Tool metadata arrives in session/update just before a sparse permission request. */
+  toolCallMetadata = /* @__PURE__ */ new Map();
+  /** Latest `available_commands_update` per session, keyed by sessionId. */
+  sessionCommands = /* @__PURE__ */ new Map();
+  supportsStandardSteering = false;
+  supportsSessionLoading = false;
+  supportsImagePrompts = false;
+  alive = false;
+  /** Bounded tail of recent stderr, so a spawn/exit failure's rejection text
+   *  carries the real reason (e.g. a harness's own "missing API key" notice)
+   *  instead of just the bare exit code, in the daemon's log. */
+  stderrTail = "";
+  agentEnv;
+  agentCommand;
+  agentLabel;
+  agentArgs;
+  agentCwd;
+  inheritProcessEnv;
+  autoApprove;
+  osSandbox;
+  permissionHandler;
+  permissionAllowlist;
+  commandsHandler;
+  constructor(opts) {
+    super();
+    const command = opts.agentCommand ?? opts.agentBinary;
+    if (!command)
+      throw new Error("ACP agent command is required");
+    this.agentCommand = command;
+    this.agentLabel = opts.agentLabel ?? command;
+    this.agentArgs = [...opts.agentArgs ?? []];
+    this.agentEnv = opts.agentEnv;
+    if (opts.agentCwd)
+      this.agentCwd = opts.agentCwd;
+    this.inheritProcessEnv = opts.inheritProcessEnv ?? process.env.BUZZY_BODY_AGENT_ENV_INHERIT === "1";
+    this.autoApprove = opts.autoApprovePermissions ?? true;
+    this.osSandbox = opts.osSandbox ?? false;
+    this.permissionHandler = opts.permissionHandler;
+    this.permissionAllowlist = opts.permissionAllowlist;
+    this.commandsHandler = opts.onCommands;
   }
-  waitForActiveRun(sessionId, timeoutMs) {
-    const current = this.activeRunIds.get(sessionId);
-    if (current)
-      return Promise.resolve(current);
-    return new Promise((resolve36, reject) => {
-      const onUpdate = (update) => {
-        if (update.sessionId !== sessionId)
-          return;
-        const runId = this.activeRunIdFromUpdate(update.update);
-        if (!runId)
-          return;
-        cleanup();
-        resolve36(runId);
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        reject(new Error(`ACP session ${sessionId} has no active run to steer`));
-      }, timeoutMs);
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.off("session/update", onUpdate);
-      };
-      this.on("session/update", onUpdate);
+  async start(timeoutMs = 6e4) {
+    if (this.alive)
+      return;
+    this.child = spawn5(this.agentCommand, this.agentArgs, {
+      // agentEnv is the child's whole environment: buildAgentEnv's allowlist is
+      // a real boundary, not a decorative one layered over a full inherit.
+      env: this.inheritProcessEnv ? { ...process.env, ...this.agentEnv } : this.agentEnv,
+      ...this.agentCwd ? { cwd: this.agentCwd } : {},
+      // The harness and every tool it spawns share a disposable process
+      // group. A hard turn deadline can therefore retire the whole tree,
+      // never just the ACP parent while a shell/compiler keeps running.
+      detached: process.platform !== "win32",
+      stdio: ["pipe", "pipe", "pipe"]
     });
-  }
-  async handlePermission(id, params) {
-    const p = params ?? {};
-    const toolCallId = p.toolCall?.toolCallId;
-    const metadataKey = p.sessionId && toolCallId ? `${p.sessionId}\0${toolCallId}` : void 0;
-    const tracked = metadataKey ? this.toolCallMetadata.get(metadataKey) : void 0;
-    if (tracked)
-      p.toolCall = { ...tracked, ...p.toolCall };
-    let decision2 = this.autoApprove ? "allow" : "reject";
-    if (!this.autoApprove && this.permissionAllowlist) {
-      try {
-        decision2 = this.permissionAllowlist(p) ? "allow" : "reject";
-      } catch (error) {
-        this.emit("permission/error", error);
-        decision2 = "reject";
+    this.alive = true;
+    this.stderrTail = "";
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => {
+      this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_TAIL_MAX_CHARS2);
+      this.emit("stderr", chunk);
+    });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.onData(chunk));
+    this.child.on("exit", (code, signal) => {
+      this.alive = false;
+      const meaningful = flattenHarnessCause(this.stderrTail);
+      const stderrSuffix = meaningful ? `: ${meaningful}` : "";
+      for (const [, p] of this.pending) {
+        this.clearTimer(p);
+        p.reject(new Error(`ACP agent ${this.agentLabel} exited code=${code} signal=${signal}${stderrSuffix}`));
       }
-    } else if (this.permissionHandler) {
-      try {
-        decision2 = await this.permissionHandler(p);
-      } catch (error) {
-        this.emit("permission/error", error);
-        decision2 = "reject";
+      this.pending.clear();
+      this.activeRunIds.clear();
+      this.activePromptSessions.clear();
+      this.toolCallMetadata.clear();
+      this.sessionCommands.clear();
+      this.emit("exit", { code, signal });
+    });
+    this.child.on("error", (err) => {
+      this.alive = false;
+      for (const [, p] of this.pending) {
+        clearTimeout(p.timer);
+        p.reject(err);
+      }
+      this.pending.clear();
+      if (this.listenerCount("error") > 0)
+        this.emit("error", err);
+    });
+    const initResult = await this.request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {}
+    }, timeoutMs);
+    const initMeta = initResult._meta;
+    const steering = initMeta?.steering;
+    this.supportsStandardSteering = steering?.supported === true;
+    const agentCapabilities = initResult.agentCapabilities;
+    this.supportsSessionLoading = agentCapabilities?.loadSession === true;
+    this.supportsImagePrompts = agentCapabilities?.promptCapabilities?.image === true;
+    this.emit("initialized", initResult);
+    if (!isPiAcpHarness(this.agentLabel))
+      this.notify("notifications/initialized", {});
+  }
+  async stop() {
+    if (!this.alive)
+      return;
+    const child = this.child;
+    if (!child)
+      return;
+    try {
+      if (this.child?.stdin.writable) {
+        this.notify("shutdown", {});
       }
+    } catch {
     }
-    if (decision2 === "allow") {
-      const allow = p?.options?.find((o) => o.kind === "allow_once" || o.kind === "allow_always") ?? p?.options?.[0];
-      if (allow?.optionId) {
-        if (metadataKey)
-          this.toolCallMetadata.delete(metadataKey);
-        this.write({
-          jsonrpc: "2.0",
-          id,
-          result: {
-            outcome: { outcome: "selected", optionId: allow.optionId }
-          }
-        });
-        return;
-      }
+    await new Promise((r2) => setTimeout(r2, 300));
+    try {
+      killChildProcessGroup(child, "SIGTERM");
+    } catch {
     }
-    const reject = p?.options?.find((o) => o.kind === "reject_once" || o.kind === "reject_always");
-    if (reject?.optionId) {
-      if (metadataKey)
-        this.toolCallMetadata.delete(metadataKey);
-      this.write({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          outcome: { outcome: "selected", optionId: reject.optionId }
-        }
-      });
-      return;
+    await new Promise((r2) => setTimeout(r2, 500));
+    try {
+      killChildProcessGroup(child, "SIGKILL");
+    } catch {
     }
-    if (metadataKey)
-      this.toolCallMetadata.delete(metadataKey);
-    this.write({
-      jsonrpc: "2.0",
-      id,
-      result: { outcome: { outcome: "cancelled" } }
-    });
+    this.child = null;
+    this.alive = false;
+    this.activeRunIds.clear();
+    this.activePromptSessions.clear();
+    this.toolCallMetadata.clear();
+  }
+  get isAlive() {
+    return this.alive;
+  }
+  /** Host pid of the harness wrapper (bwrap when enabled). */
+  processPid() {
+    return this.child?.pid;
+  }
+  /** The latest command list this harness advertised for a session, if any. */
+  sessionCommandsFor(sessionId) {
+    return this.sessionCommands.get(sessionId) ?? [];
+  }
+  /** Whether this live ACP process advertised the stable `session/load` method. */
+  canLoadSession() {
+    return this.supportsSessionLoading;
+  }
+  /** Whether this live ACP process accepts `image` prompt blocks (`promptCapabilities.image`). */
+  canPromptWithImages() {
+    return this.supportsImagePrompts;
+  }
+  async sessionNew(opts) {
+    const params = {
+      cwd: opts.cwd,
+      mcpServers: (opts.mcpServers ?? []).map((s) => ({
+        name: s.name,
+        command: s.command,
+        args: s.args ?? [],
+        env: s.env ?? []
+      }))
+    };
+    if (opts.systemPrompt)
+      params.systemPrompt = opts.systemPrompt;
+    const meta = {
+      ...sessionToolScopeMeta(this.agentLabel) ?? {}
+    };
+    if (opts.systemPrompt && harnessReadsMetaSystemPrompt(this.agentLabel)) {
+      meta.systemPrompt = { append: opts.systemPrompt };
+    }
+    if (Object.keys(meta).length > 0)
+      params._meta = meta;
+    const raw = await this.request("session/new", params, opts.timeoutMs ?? 6e4);
+    const sessionId = raw.sessionId;
+    if (!sessionId)
+      throw new Error("session/new missing sessionId");
+    await this.applySessionMode(sessionId, raw, opts.mode);
+    return { sessionId, raw };
   }
   /**
-   * `onStart`, when given, receives the assigned request id synchronously
-   * and marks the request as idle-resettable at `timeoutMs`: callers can
-   * then call `resetPendingIdleTimeout(id)` on activity to defer the
-   * timeout instead of it firing at a fixed deadline.
+   * Reopen a provider-persisted logical conversation in this new ACP process.
+   * Unlike `session/new`, load accepts no system prompt: the harness restores
+   * its own conversation and instructions instead of receiving transcript
+   * text from Body again.
    */
-  request(method, params, timeoutMs = 6e4, onStart, detail = "") {
-    if (!this.child || !this.alive) {
-      return Promise.reject(new Error("AcpClient not started"));
+  async sessionLoad(opts) {
+    if (!this.supportsSessionLoading) {
+      throw new Error("ACP agent does not advertise session/load");
     }
-    const id = this.nextId++;
-    const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve36, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart), detail));
-      }, timeoutMs);
-      this.pending.set(id, {
-        resolve: resolve36,
-        reject,
-        timer,
-        method,
-        ...detail ? { detail } : {},
-        ...onStart ? { idleTimeoutMs: timeoutMs } : {}
-      });
-      onStart?.(id);
-      this.write(payload);
-    });
-  }
-  notify(method, params) {
-    this.write({ jsonrpc: "2.0", method, params });
+    const params = {
+      sessionId: opts.sessionId,
+      cwd: opts.cwd,
+      mcpServers: (opts.mcpServers ?? []).map((server) => ({
+        name: server.name,
+        command: server.command,
+        args: server.args ?? [],
+        env: server.env ?? []
+      }))
+    };
+    const meta = sessionToolScopeMeta(this.agentLabel);
+    if (meta)
+      params._meta = meta;
+    const result = await this.request("session/load", params);
+    const raw = result && typeof result === "object" ? result : {};
+    await this.applySessionMode(opts.sessionId, raw, opts.mode);
+    return { sessionId: opts.sessionId, raw };
   }
-  write(obj) {
-    if (!this.child?.stdin.writable)
+  async applySessionMode(sessionId, raw, mode) {
+    if (!mode)
       return;
-    this.child.stdin.write(JSON.stringify(obj) + "\n");
+    const modes = raw.modes;
+    const candidates = mode === "readonly" ? roomModeCandidates(this.agentLabel, { osSandbox: this.osSandbox }) : cornerAutonomyModeCandidates(this.agentLabel);
+    const target = modes?.availableModes?.find((candidate) => candidate.id && candidates.includes(candidate.id))?.id;
+    if (!target || modes?.currentModeId === target)
+      return;
+    await this.request("session/set_mode", { sessionId, modeId: target });
   }
-};
-
-// apps/body/dist/model-types.js
-var ALLOWED = /* @__PURE__ */ new Set(["model", "thought_level", "effort", "reasoning_effort"]);
-function isAllowedAgentModelConfigCategory(category) {
-  return ALLOWED.has(category);
-}
-
-// apps/body/dist/model-config.js
-import { lstatSync as lstatSync2, readFileSync as readFileSync2 } from "node:fs";
-import { basename as basename3, resolve as resolve4 } from "node:path";
-var GROK_SESSION_MODEL_AXIS_ID = "beeline:grok-session-model";
-var GROK_LAUNCH_EFFORT_AXIS_ID = "beeline:grok-launch-reasoning-effort";
-function isGrokAgentCommand(agent) {
-  if (agent.kind === "grok")
-    return true;
-  if (agent.kind && agent.kind !== "custom")
-    return false;
-  return /^grok(?:\.[a-z0-9]+)?$/i.test(basename3(agent.command));
-}
-function agentArgsWithModelSelection(agent, selection) {
-  const original = [...agent.args];
-  if (!selection || !isGrokAgentCommand(agent) || !original.includes("agent") || !original.includes("stdio")) {
-    return original;
+  /**
+   * Run one prompt turn. `timeoutMs` is an idle window, not a hard cap on
+   * turn length: every `session/update` for this session (message chunk,
+   * tool call, or otherwise) re-arms it, so an actively-working agent can
+   * run indefinitely while a genuinely wedged one (zero activity for
+   * `timeoutMs`) still gets cancelled. `onChunk` is the ACP-boundary
+   * streaming hook: called for every incremental `agent_message_chunk`
+   * delta as it arrives, so a caller can project live text without waiting
+   * for the turn to finish. A harness that only emits a final message
+   * (never chunks) simply never invokes it — `agentText` is unaffected
+   * either way. `onActivity`, when given, fires on every `session/update`
+   * regardless of kind (the same trigger that re-arms the idle timer above),
+   * so a caller can drive its own shorter "still working" notice off the
+   * identical genuine-activity signal without duplicating the timeout logic.
+   * It receives the current lane snapshot; existing callbacks that ignore
+   * arguments remain valid.
+   */
+  async sessionPrompt(sessionId, text2, timeoutMs = 12e4, onChunk, onActivity, onToolCalls) {
+    const updates = [];
+    let promptRunId;
+    let requestId;
+    const onUpdate = (u4) => {
+      if (u4.sessionId !== sessionId)
+        return;
+      updates.push(u4);
+      promptRunId ??= this.activeRunIdFromUpdate(u4.update);
+      if (requestId !== void 0)
+        this.resetPendingIdleTimeout(requestId);
+      onActivity?.(agentStreamSnapshot(updates, this.agentLabel));
+      onToolCalls?.(toolCallEntries(updates));
+      if (onChunk) {
+        const delta = agentMessageChunkText(u4.update);
+        if (delta) {
+          const runs = agentMessageRuns(updates, this.agentLabel);
+          onChunk(delta, runs.join("\n\n"), runs.at(-1), runs);
+        }
+      }
+    };
+    this.on("session/update", onUpdate);
+    this.activePromptSessions.add(sessionId);
+    try {
+      const result = await this.request("session/prompt", {
+        sessionId,
+        prompt: typeof text2 === "string" ? [{ type: "text", text: text2 }] : [...text2]
+      }, timeoutMs, (id) => {
+        requestId = id;
+      }, promptPayloadNote(text2));
+      const agentText = finalAgentMessageText(updates, this.agentLabel);
+      const toolCalls = toolCallEntries(updates);
+      return {
+        stopReason: result?.stopReason ?? "end_turn",
+        updates,
+        agentText,
+        toolCalls
+      };
+    } finally {
+      this.activePromptSessions.delete(sessionId);
+      if (promptRunId && this.activeRunIds.get(sessionId) === promptRunId) {
+        this.activeRunIds.delete(sessionId);
+      }
+      this.off("session/update", onUpdate);
+    }
   }
-  const stripped = [];
-  for (let index = 0; index < original.length; index += 1) {
-    const arg = original[index];
-    if (arg === "-m" || arg === "--model" || arg === "--reasoning-effort") {
-      index += 1;
-      continue;
+  /**
+   * Inject follow-up input into the prompt currently running for this session.
+   * buzz-agent advertises the target run through ACP session metadata; binding
+   * the request to that id prevents a late message from steering a newer turn.
+   */
+  async sessionSteer(sessionId, text2, timeoutMs = 6e4) {
+    if (this.supportsStandardSteering) {
+      const raw2 = await this.request("_session/steering", {
+        sessionId,
+        prompt: [{ type: "text", text: text2 }]
+      }, timeoutMs);
+      if (!raw2.outcome || raw2.outcome === "failed") {
+        throw new Error("ACP session steering failed");
+      }
+      return {
+        runId: this.activeRunId(sessionId) ?? `session:${sessionId}`,
+        messageId: raw2.outcome
+      };
     }
-    if (arg.startsWith("--model=") || arg.startsWith("--reasoning-effort=") || /^-m=/.test(arg)) {
-      continue;
+    const expectedRunId = await this.waitForActiveRun(sessionId, Math.min(timeoutMs, 5e3));
+    const raw = await this.request("_goose/unstable/session/steer", {
+      sessionId,
+      prompt: [{ type: "text", text: text2 }],
+      expectedRunId
+    }, timeoutMs);
+    if (!raw.runId || !raw.messageId) {
+      throw new Error("ACP session steer response missing runId or messageId");
     }
-    stripped.push(arg);
+    return { runId: raw.runId, messageId: raw.messageId };
   }
-  const stdioIndex = stripped.lastIndexOf("stdio");
-  const configured = [
-    ...selection.model ? ["--model", selection.model] : [],
-    ...selection.effort ? ["--reasoning-effort", selection.effort] : []
-  ];
-  stripped.splice(stdioIndex, 0, ...configured);
-  return stripped;
-}
-function advertisedChoiceId(choice) {
-  if (typeof choice.id === "string" && choice.id.length > 0)
-    return choice.id;
-  if (typeof choice.value === "string" && choice.value.length > 0)
-    return choice.value;
-  return void 0;
-}
-function sortModelChoicesNewestFirst(choices) {
-  return choices.map((choice, index) => ({ choice, index })).sort((left, right) => {
-    const leftParts = left.choice.id.match(/\d+/g)?.map(Number) ?? [];
-    const rightParts = right.choice.id.match(/\d+/g)?.map(Number) ?? [];
-    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
-      const delta = (rightParts[index] ?? -1) - (leftParts[index] ?? -1);
-      if (delta !== 0)
-        return delta;
-    }
-    return left.index - right.index;
-  }).map(({ choice }) => choice);
-}
-function parseAdvertisedConfigOptions(raw, preferredModelId, includeLaunchEffort = false) {
-  const configOptions = raw?.configOptions;
-  const result = [];
-  for (const entry of Array.isArray(configOptions) ? configOptions : []) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const record3 = entry;
-    const id = record3.id;
-    const category = record3.category;
-    if (typeof id !== "string" || typeof category !== "string")
-      continue;
-    const rawChoices = Array.isArray(record3.options) ? record3.options : [];
-    const choices = [];
-    for (const rawChoice of rawChoices) {
-      if (!rawChoice || typeof rawChoice !== "object")
-        continue;
-      const choice = rawChoice;
-      const choiceId = advertisedChoiceId(choice);
-      if (!choiceId)
-        continue;
-      choices.push({
-        id: choiceId,
-        ...typeof choice.name === "string" ? { name: choice.name } : {}
-      });
-    }
-    result.push({
-      id,
-      category,
-      ...typeof record3.currentValue === "string" ? { currentValue: record3.currentValue } : {},
-      options: category === "model" ? sortModelChoicesNewestFirst(choices) : choices
-    });
+  /** Active ACP run for a session, if the agent has advertised one. */
+  activeRunId(sessionId) {
+    return this.activeRunIds.get(sessionId) ?? (this.activePromptSessions.has(sessionId) ? `session:${sessionId}` : void 0);
   }
-  const models = raw?.models;
-  if (!models || typeof models !== "object")
-    return result;
-  const modelState = models;
-  const availableModels = Array.isArray(modelState.availableModels) ? modelState.availableModels : [];
-  const modelChoices = [];
-  for (const entry of availableModels) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const model = entry;
-    if (typeof model.modelId !== "string" || !model.modelId)
-      continue;
-    modelChoices.push({
-      id: model.modelId,
-      ...typeof model.name === "string" ? { name: model.name } : {}
-    });
+  sessionCancel(sessionId) {
+    this.notify("session/cancel", { sessionId });
   }
-  const currentModelId = typeof modelState.currentModelId === "string" ? modelState.currentModelId : void 0;
-  if (modelChoices.length > 0 && !result.some((axis) => axis.category === "model")) {
-    result.push({
-      id: GROK_SESSION_MODEL_AXIS_ID,
-      category: "model",
-      ...currentModelId ? { currentValue: currentModelId } : {},
-      options: sortModelChoicesNewestFirst(modelChoices)
-    });
+  /**
+   * The portable model/effort setter, confirmed round-tripping on pi/codex/
+   * claude (report `data/buzzy-multiagent-runtimes/report.md` §3.2). The
+   * param is `configId`, not `optionId`. Harnesses that advertise this shape
+   * must use it; `session/set_model` is reserved for the distinct standard
+   * `session/new.models` shape. Returns the runtime's updated `configOptions`.
+   * Callers must validate `configId`/`value` against the
+   * allow-listed catalog before calling this — see
+   * `apps/body/src/model-config.ts`'s `assertModelConfigOptionAllowed`; this
+   * method performs no policy checks of its own.
+   */
+  async setConfigOption(sessionId, configId, value) {
+    return this.request("session/set_config_option", { sessionId, configId, value });
   }
-  const effortModelId = preferredModelId ?? currentModelId;
-  const currentModel = availableModels.find((entry) => entry && typeof entry === "object" && entry.modelId === effortModelId);
-  const meta = currentModel?._meta;
-  const modelMeta = meta && typeof meta === "object" ? meta : void 0;
-  const efforts = Array.isArray(modelMeta?.reasoningEfforts) ? modelMeta.reasoningEfforts : [];
-  const effortChoices = [];
-  for (const entry of efforts) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const effort = entry;
-    const id = advertisedChoiceId(effort);
-    if (!id)
-      continue;
-    effortChoices.push({
-      id,
-      ...typeof effort.label === "string" ? { name: effort.label } : typeof effort.name === "string" ? { name: effort.name } : {}
-    });
+  /**
+   * Standard ACP model setter used only when `session/new.models` supplied the
+   * corresponding safe model axis. Most Beeline harnesses use configOptions;
+   * Grok currently exposes models through this standard method instead.
+   */
+  async setModel(sessionId, modelId) {
+    return this.request("session/set_model", { sessionId, modelId });
   }
-  const hasEffortAxis = result.some((axis) => ["thought_level", "effort", "reasoning_effort"].includes(axis.category));
-  if (includeLaunchEffort && effortChoices.length > 0 && !hasEffortAxis) {
-    const currentEffort = typeof modelMeta?.reasoningEffort === "string" ? modelMeta.reasoningEffort : efforts.find((entry) => entry && typeof entry === "object" && entry.default)?.value;
-    result.push({
-      id: GROK_LAUNCH_EFFORT_AXIS_ID,
-      category: "reasoning_effort",
-      ...typeof currentEffort === "string" ? { currentValue: currentEffort } : {},
-      options: effortChoices
-    });
+  clearTimer(p) {
+    if (p.timer) {
+      clearTimeout(p.timer);
+      p.timer = void 0;
+    }
   }
-  return result;
-}
-function filterAllowedModelConfigOptions(options) {
-  return options.filter((option) => isAllowedAgentModelConfigCategory(option.category));
-}
-var PROVIDER_CREDENTIAL_ENV_HINTS = {
-  openai: ["OPENAI_API_KEY", "OPENAI_COMPAT_API_KEY"],
-  openrouter: ["OPENROUTER_API_KEY"],
-  anthropic: ["ANTHROPIC_API_KEY"],
-  google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
-  groq: ["GROQ_API_KEY"],
-  mistral: ["MISTRAL_API_KEY"],
-  deepseek: ["DEEPSEEK_API_KEY"],
-  xai: ["XAI_API_KEY"],
-  cohere: ["COHERE_API_KEY"],
-  together: ["TOGETHER_API_KEY"],
-  fireworks: ["FIREWORKS_API_KEY"]
-};
-function credentialedProviders(env) {
-  const held = /* @__PURE__ */ new Set();
-  for (const [provider, names] of Object.entries(PROVIDER_CREDENTIAL_ENV_HINTS)) {
-    if (names.some((name) => Boolean(env[name]?.trim())))
-      held.add(provider);
+  /**
+   * Re-arm a pending request's idle timer from its full `idleTimeoutMs`,
+   * called on every ACP activity signal for that request (streamed text
+   * delta, session/update, tool call). A request only times out after this
+   * much wall-clock time with zero activity, not after a fixed deadline —
+   * so an actively-working turn can run indefinitely while a genuinely
+   * wedged one still gets caught.
+   */
+  resetPendingIdleTimeout(id) {
+    const p = this.pending.get(id);
+    if (!p || p.idleTimeoutMs === void 0)
+      return;
+    this.clearTimer(p);
+    const { idleTimeoutMs, method, reject, detail } = p;
+    p.timer = setTimeout(() => {
+      this.pending.delete(id);
+      reject(new AcpRequestTimeoutError(method ?? "request", idleTimeoutMs, this.stderrTail, true, detail ?? ""));
+    }, idleTimeoutMs);
   }
-  for (const provider of credentialedPiCustomProviders(env))
-    held.add(provider);
-  return held;
-}
-function credentialedPiCustomProviders(env) {
-  const agentDir = env.PI_CODING_AGENT_DIR?.trim() ? resolve4(env.PI_CODING_AGENT_DIR) : env.HOME?.trim() ? resolve4(env.HOME, ".pi/agent") : void 0;
-  const held = /* @__PURE__ */ new Set();
-  if (!agentDir)
-    return held;
-  const path = resolve4(agentDir, "models.json");
-  try {
-    const stats = lstatSync2(path);
-    if (!stats.isFile() || stats.isSymbolicLink() || stats.nlink !== 1 || stats.size > 1048576) {
-      return held;
+  onData(chunk) {
+    this.buf += chunk;
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      const line = this.buf.slice(0, nl).trim();
+      this.buf = this.buf.slice(nl + 1);
+      if (!line)
+        continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      this.handleMessage(msg);
     }
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    const providers = parsed.providers;
-    const remember = (name, config) => {
-      if (typeof name !== "string" || !name.trim() || !config || typeof config !== "object")
+  }
+  handleMessage(msg) {
+    const id = msg.id;
+    const method = msg.method;
+    if (id !== void 0 && !method) {
+      const n3 = Number(id);
+      const p = this.pending.get(n3);
+      if (!p)
+        return;
+      this.pending.delete(n3);
+      this.clearTimer(p);
+      if (msg.error) {
+        const err = msg.error;
+        const details = typeof err.data?.details === "string" && err.data.details.trim() ? err.data.details.replace(/\s+/g, " ").trim() : "";
+        const meaningful = flattenHarnessCause(this.stderrTail);
+        const extra = [details, meaningful ? `harness stderr: ${meaningful}` : ""].filter(Boolean).join("; ");
+        p.reject(new Error(`ACP error ${err.code}: ${err.message}${extra ? `; ${extra}` : ""}`));
+      } else {
+        p.resolve(msg.result);
+      }
+      return;
+    }
+    if (method && id !== void 0) {
+      if (method === "session/request_permission") {
+        void this.handlePermission(id, msg.params);
         return;
-      const apiKey = config.apiKey;
-      if (typeof apiKey === "string" && apiKey.trim())
-        held.add(name.trim());
-    };
-    if (Array.isArray(providers)) {
-      for (const provider of providers) {
-        const record3 = provider;
-        remember(record3?.name ?? record3?.id, record3);
       }
-    } else if (providers && typeof providers === "object") {
-      for (const [name, config] of Object.entries(providers)) {
-        remember(name, config);
+      this.write({ jsonrpc: "2.0", id, result: {} });
+      return;
+    }
+    if (method === "session/update") {
+      const params = msg.params;
+      if (params?.sessionId && params.update) {
+        if (params.update.sessionUpdate === "available_commands_update") {
+          const commands = parseAvailableCommands(params.update.availableCommands);
+          this.sessionCommands.set(params.sessionId, commands);
+          this.commandsHandler?.(commands);
+          this.emit("commands", { sessionId: params.sessionId, commands });
+        }
+        const toolCallId = params.update.toolCallId;
+        const sessionUpdate = params.update.sessionUpdate;
+        if (typeof toolCallId === "string" && (sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update")) {
+          const metadataKey = `${params.sessionId}\0${toolCallId}`;
+          const status = params.update.status;
+          if (status === "completed" || status === "failed") {
+            this.toolCallMetadata.delete(metadataKey);
+          } else {
+            const existing = this.toolCallMetadata.get(metadataKey);
+            this.toolCallMetadata.set(metadataKey, {
+              ...existing,
+              toolCallId,
+              ...typeof params.update.title === "string" ? { title: params.update.title } : {},
+              ...typeof params.update.kind === "string" ? { kind: params.update.kind } : {},
+              ..."rawInput" in params.update ? { rawInput: params.update.rawInput } : {},
+              // `content`/`locations` carry the touched file paths for adapters
+              // whose permission request omits them (codex-acp's file-change
+              // request has no rawInput at all) — the corner worktree guard in
+              // `session-sandbox.ts` reads them.
+              ..."content" in params.update ? { content: params.update.content } : {},
+              ..."locations" in params.update ? { locations: params.update.locations } : {}
+            });
+          }
+        }
+        const u4 = {
+          sessionId: params.sessionId,
+          update: params.update
+        };
+        const activeRunId = this.activeRunIdFromUpdate(params.update);
+        if (activeRunId)
+          this.activeRunIds.set(params.sessionId, activeRunId);
+        this.emit("session/update", u4);
       }
+      return;
     }
-  } catch {
   }
-  return held;
-}
-function filterModelOptionsByCredentials(options, env) {
-  const held = credentialedProviders(env);
-  return options.map((option) => {
-    if (option.category !== "model")
-      return option;
-    return {
-      ...option,
-      options: option.options.filter((choice) => {
-        const slash = choice.id.indexOf("/");
-        if (slash < 0)
-          return true;
-        return held.has(choice.id.slice(0, slash));
-      })
-    };
-  });
-}
-var DisallowedModelConfigOptionError = class extends Error {
-  constructor(configId) {
-    super(`model config option "${configId}" is not in the allow-listed catalog`);
-    this.name = "DisallowedModelConfigOptionError";
+  activeRunIdFromUpdate(update) {
+    const meta = update._meta;
+    const goose = meta?.goose;
+    return typeof goose?.activeRunId === "string" && goose.activeRunId ? goose.activeRunId : void 0;
   }
-};
-var ModelSelectionUnavailableError = class extends Error {
-  label;
-  value;
-  reason;
-  guidance;
-  constructor(input) {
-    const recovery = input.guidance ? ` ${input.guidance}` : " Choose one of the values in the live harness catalog.";
-    super(`${input.label} "${input.value}" is unavailable.${recovery}`);
-    this.name = "ModelSelectionUnavailableError";
-    this.label = input.label;
-    this.value = input.value;
-    this.reason = input.reason;
-    this.guidance = input.guidance;
+  waitForActiveRun(sessionId, timeoutMs) {
+    const current = this.activeRunIds.get(sessionId);
+    if (current)
+      return Promise.resolve(current);
+    return new Promise((resolve36, reject) => {
+      const onUpdate = (update) => {
+        if (update.sessionId !== sessionId)
+          return;
+        const runId = this.activeRunIdFromUpdate(update.update);
+        if (!runId)
+          return;
+        cleanup();
+        resolve36(runId);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`ACP session ${sessionId} has no active run to steer`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.off("session/update", onUpdate);
+      };
+      this.on("session/update", onUpdate);
+    });
   }
-};
-function withEffectiveCurrentValues(options, selection) {
-  if (!selection || !selection.model && !selection.effort)
-    return options;
-  return options.map((option) => {
-    const target = modelSelectionTargets(selection).find((entry) => entry.categories.includes(option.category));
-    if (!target?.value || option.currentValue === target.value)
-      return option;
-    return { ...option, currentValue: target.value };
-  });
-}
-function modelSelectionTargets(selection) {
-  return [
-    { categories: ["model"], label: "model", value: selection.model },
-    {
-      categories: ["thought_level", "effort", "reasoning_effort"],
-      label: "effort",
-      value: selection.effort
+  async handlePermission(id, params) {
+    const p = params ?? {};
+    const toolCallId = p.toolCall?.toolCallId;
+    const metadataKey = p.sessionId && toolCallId ? `${p.sessionId}\0${toolCallId}` : void 0;
+    const tracked = metadataKey ? this.toolCallMetadata.get(metadataKey) : void 0;
+    if (tracked)
+      p.toolCall = { ...tracked, ...p.toolCall };
+    let decision2 = this.autoApprove ? "allow" : "reject";
+    if (!this.autoApprove && this.permissionAllowlist) {
+      try {
+        decision2 = this.permissionAllowlist(p) ? "allow" : "reject";
+      } catch (error) {
+        this.emit("permission/error", error);
+        decision2 = "reject";
+      }
+    } else if (this.permissionHandler) {
+      try {
+        decision2 = await this.permissionHandler(p);
+      } catch (error) {
+        this.emit("permission/error", error);
+        decision2 = "reject";
+      }
     }
-  ];
-}
-function assertModelSelectionAdvertised(advertisedOptions, selection) {
-  for (const target of modelSelectionTargets(selection)) {
-    if (!target.value)
-      continue;
-    const axis = advertisedOptions.find((option) => target.categories.includes(option.category));
-    if (!axis) {
-      continue;
+    if (decision2 === "allow") {
+      const allow = p?.options?.find((o) => o.kind === "allow_once" || o.kind === "allow_always") ?? p?.options?.[0];
+      if (allow?.optionId) {
+        if (metadataKey)
+          this.toolCallMetadata.delete(metadataKey);
+        this.write({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            outcome: { outcome: "selected", optionId: allow.optionId }
+          }
+        });
+        return;
+      }
     }
-    assertModelConfigAxisAllowed(axis.id, advertisedOptions);
-    if (!axis.options.some((choice) => choice.id === target.value)) {
-      throw new ModelSelectionUnavailableError({
-        label: target.label,
-        value: target.value,
-        reason: "not-advertised"
+    const reject = p?.options?.find((o) => o.kind === "reject_once" || o.kind === "reject_always");
+    if (reject?.optionId) {
+      if (metadataKey)
+        this.toolCallMetadata.delete(metadataKey);
+      this.write({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          outcome: { outcome: "selected", optionId: reject.optionId }
+        }
       });
+      return;
     }
+    if (metadataKey)
+      this.toolCallMetadata.delete(metadataKey);
+    this.write({
+      jsonrpc: "2.0",
+      id,
+      result: { outcome: { outcome: "cancelled" } }
+    });
   }
-}
-function assertModelConfigAxisAllowed(configId, advertisedOptions) {
-  const axis = advertisedOptions.find((option) => option.id === configId);
-  if (!axis || !isAllowedAgentModelConfigCategory(axis.category)) {
-    throw new DisallowedModelConfigOptionError(configId);
-  }
-}
-async function applyAgentModelSelection(client, sessionId, advertisedOptions, selection) {
-  assertModelSelectionAdvertised(advertisedOptions, selection);
-  for (const target of modelSelectionTargets(selection)) {
-    if (!target.value)
-      continue;
-    const axis = advertisedOptions.find((option) => target.categories.includes(option.category));
-    if (!axis)
-      continue;
-    assertModelConfigAxisAllowed(axis.id, advertisedOptions);
-    try {
-      if (axis.id === GROK_SESSION_MODEL_AXIS_ID) {
-        if (!client.setModel)
-          throw new Error("ACP client does not support session/set_model");
-        await client.setModel(sessionId, target.value);
-      } else if (axis.id === GROK_LAUNCH_EFFORT_AXIS_ID) {
-        if (axis.currentValue !== target.value) {
-          throw new Error(`Grok started with reasoning effort "${axis.currentValue ?? "unknown"}", not "${target.value}"`);
-        }
-      } else {
-        await client.setConfigOption(sessionId, axis.id, target.value);
-      }
-    } catch (error) {
-      throw new ModelSelectionUnavailableError({
-        label: target.label,
-        value: target.value,
-        reason: "provider-refused",
-        guidance: error instanceof Error ? error.message : String(error)
+  /**
+   * `onStart`, when given, receives the assigned request id synchronously
+   * and marks the request as idle-resettable at `timeoutMs`: callers can
+   * then call `resetPendingIdleTimeout(id)` on activity to defer the
+   * timeout instead of it firing at a fixed deadline.
+   */
+  request(method, params, timeoutMs = 6e4, onStart, detail = "") {
+    if (!this.child || !this.alive) {
+      return Promise.reject(new Error("AcpClient not started"));
+    }
+    const id = this.nextId++;
+    const payload = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve36, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart), detail));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: resolve36,
+        reject,
+        timer,
+        method,
+        ...detail ? { detail } : {},
+        ...onStart ? { idleTimeoutMs: timeoutMs } : {}
       });
-    }
+      onStart?.(id);
+      this.write(payload);
+    });
   }
-}
+  notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+  write(obj) {
+    if (!this.child?.stdin.writable)
+      return;
+    this.child.stdin.write(JSON.stringify(obj) + "\n");
+  }
+};
 
 // apps/body/dist/model-catalog.js
 function modelCatalogProbeEnvironment(agent, agentEnv, scratchCwd) {
@@ -16109,27 +16133,34 @@ async function withAgentModelCatalog(agent, agentEnv, selection, inspect, limits
 async function fetchAgentModelCatalog(agent, agentEnv, selection, limits = {}) {
   return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => ({
     raw,
-    catalog: await filterModelChoicesByLiveValidation(client, sessionId, catalog)
+    catalog: await filterModelChoicesByLiveValidation(client, sessionId, catalog, selection?.model)
   }), limits);
 }
-async function filterModelChoicesByLiveValidation(client, sessionId, catalog) {
+async function filterModelChoicesByLiveValidation(client, sessionId, catalog, preferredModelId) {
   const modelAxis = catalog.find((axis) => axis.category === "model");
   if (!modelAxis)
     return catalog;
   const available = [];
+  const preferred = preferredModelId ?? modelAxis.currentValue;
+  let preferredCatalog;
   for (const choice of modelAxis.options) {
     try {
-      await applyAgentModelSelection(client, sessionId, catalog, { model: choice.id });
+      const updated = await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, catalog, {
+        model: choice.id
+      });
       available.push(choice);
+      if (choice.id === preferred)
+        preferredCatalog = updated;
     } catch {
     }
   }
-  return catalog.map((axis) => axis === modelAxis ? { ...axis, options: available } : axis);
+  const effective = preferredCatalog ?? catalog;
+  return effective.map((axis) => axis.category === "model" ? { ...axis, options: available } : axis);
 }
 async function validateAgentModelSelection(agent, agentEnv, selection) {
   return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => {
-    await applyAgentModelSelection(client, sessionId, catalog, selection);
-    return { raw, catalog };
+    const applied = await applyAgentModelSelectionWithUpdatedCatalog(client, sessionId, catalog, selection);
+    return { raw, catalog: applied };
   });
 }
 
@@ -16159,19 +16190,33 @@ function modelUnavailableState(selection, error) {
 }
 
 // apps/body/dist/runtime-model-validation.js
-async function revalidateRuntimeModelSelection(agent, agentEnv, selection, validate = validateAgentModelSelection) {
+async function revalidateRuntimeModelSelection(agent, agentEnv, selection, validate = validateAgentModelSelection, refreshAdapter) {
   if (!selection.model && !selection.effort)
     return void 0;
   try {
     await validate(agent, agentEnv, selection);
     return void 0;
   } catch (error) {
+    const selectedModelMissing = error instanceof ModelSelectionUnavailableError && error.label === "model" && (error.reason === "axis-missing" || error.reason === "not-advertised");
+    if (selectedModelMissing && refreshAdapter) {
+      try {
+        await refreshAdapter();
+      } catch {
+        return modelUnavailableState(selection, error);
+      }
+      try {
+        await validate(agent, agentEnv, selection);
+        return void 0;
+      } catch (retryError) {
+        return modelUnavailableState(selection, retryError);
+      }
+    }
     return modelUnavailableState(selection, error);
   }
 }
-async function applyRuntimeModelPreflight(config, agent, selection, validate = validateAgentModelSelection) {
+async function applyRuntimeModelPreflight(config, agent, selection, validate = validateAgentModelSelection, refreshAdapter) {
   config.modelSelection = selection;
-  config.modelUnavailable = await revalidateRuntimeModelSelection(agent, config.agentEnv, selection, validate);
+  config.modelUnavailable = await revalidateRuntimeModelSelection(agent, config.agentEnv, selection, validate, refreshAdapter);
 }
 
 // apps/body/dist/model-catalog-sync.js
@@ -16215,7 +16260,7 @@ async function syncAgentModelCatalog(input) {
     const effectiveCatalog = input.startupUnavailable ? catalog : withEffectiveCurrentValues(catalog, selection);
     const hash = modelCatalogHash(effectiveCatalog, selection, input.startupUnavailable);
     const previous = await readFile(hashPath, "utf8").catch(() => "");
-    if (previous.trim() === hash)
+    if (!input.force && previous.trim() === hash)
       return "unchanged";
     await input.api.execute("postAgentModelCatalog", {
       agentId: input.agentId,
@@ -16767,7 +16812,7 @@ function describe(error) {
 }
 
 // apps/body/dist/connector-squire.js
-import { execFile, spawn as spawn5 } from "node:child_process";
+import { execFile, spawn as spawn6 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { lstatSync as lstatSync3, readFileSync as readFileSync4, realpathSync, rmSync } from "node:fs";
 import { homedir as homedir3, hostname, tmpdir as tmpdir2 } from "node:os";
@@ -16916,7 +16961,7 @@ function killConnectTree(child) {
   child.kill();
 }
 var defaultStreamedRunner = (command, args, env) => new Promise((resolve36) => {
-  const child = spawn5(command, args, {
+  const child = spawn6(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
     env: env ?? squireConnectProcessEnv(),
     detached: true
@@ -17316,8 +17361,173 @@ async function revokeGrants(mcp, ref) {
   return { revoked, failed };
 }
 
+// apps/body/dist/connector-tailscale.js
+import { execFile as execFile2 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir3, userInfo } from "node:os";
+import { join as join5 } from "node:path";
+var COMMAND_TIMEOUT_MS = 2 * 6e4;
+var OUTPUT_LIMIT = 32 * 1024;
+var LOGIN_URL = /https:\/\/login\.tailscale\.com\/[A-Za-z0-9_/-]+/u;
+function clipped(value) {
+  return value.length <= OUTPUT_LIMIT ? value : value.slice(value.length - OUTPUT_LIMIT);
+}
+var runTailscaleCommand = (command, args) => new Promise((resolve36) => {
+  execFile2(command, [...args], { timeout: COMMAND_TIMEOUT_MS, maxBuffer: OUTPUT_LIMIT * 2 }, (error, stdout6, stderr) => {
+    const code = error && "code" in error && typeof error.code === "number" ? error.code : error ? null : 0;
+    resolve36({ code, stdout: clipped(stdout6), stderr: clipped(stderr) });
+  });
+});
+function parseStatus(output) {
+  try {
+    const parsed = JSON.parse(output);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function accountName(status) {
+  const userId = status.Self?.UserID;
+  const user = userId === void 0 ? void 0 : status.User?.[String(userId)];
+  return user?.LoginName ?? user?.DisplayName ?? status.CurrentTailnet?.Name;
+}
+function step3(label, status, details = {}) {
+  return { label, status, ...details };
+}
+async function readStatus(run2) {
+  const result = await run2("tailscale", ["status", "--json"]);
+  return parseStatus(result.stdout || result.stderr);
+}
+async function ensureInstalled(run2, onProgress, platform) {
+  const version = await run2("tailscale", ["version"]);
+  if (version.code === 0) {
+    return {
+      ok: true,
+      steps: [step3("Tailscale installed", "done", { output: version.stdout.trim() })]
+    };
+  }
+  if (platform !== "linux") {
+    const reason = "Tailscale is not installed; install the Tailscale app on this helper and retry";
+    return {
+      ok: false,
+      result: {
+        status: "error",
+        steps: [step3("Tailscale installed", "failed", { reason })],
+        errorMessage: reason
+      }
+    };
+  }
+  const script = join5(tmpdir3(), `beeline-tailscale-install-${process.pid}-${randomUUID2()}.sh`);
+  const steps = [
+    step3("Tailscale installed", "running", {
+      command: "curl -fsSL https://tailscale.com/install.sh"
+    }),
+    step3("Tailnet signed in", "pending")
+  ];
+  onProgress(steps);
+  try {
+    const download = await run2("curl", ["-fsSL", "https://tailscale.com/install.sh", "-o", script]);
+    if (download.code !== 0) {
+      const reason = (download.stderr || download.stdout || "Tailscale installer download failed").trim();
+      return {
+        ok: false,
+        result: {
+          status: "error",
+          steps: [step3("Tailscale installed", "failed", { reason })],
+          errorMessage: reason
+        }
+      };
+    }
+    const install = await run2("sh", [script]);
+    if (install.code !== 0) {
+      const reason = (install.stderr || install.stdout || "Tailscale installation failed").trim();
+      return {
+        ok: false,
+        result: {
+          status: "error",
+          steps: [step3("Tailscale installed", "failed", { reason })],
+          errorMessage: reason
+        }
+      };
+    }
+    return {
+      ok: true,
+      steps: [step3("Tailscale installed", "done", { output: install.stdout.trim() })]
+    };
+  } finally {
+    await rm2(script, { force: true }).catch(() => {
+    });
+  }
+}
+async function installTailscale(options = {}) {
+  const run2 = options.run ?? runTailscaleCommand;
+  const onProgress = options.onProgress ?? (() => {
+  });
+  const platform = options.platform ?? process.platform;
+  const installed = await ensureInstalled(run2, onProgress, platform);
+  if (!installed.ok)
+    return installed.result;
+  const current = await readStatus(run2);
+  if (current?.BackendState === "Running") {
+    return {
+      status: "connected",
+      steps: [...installed.steps, step3("Tailnet signed in", "done")],
+      ...accountName(current) ? { signedInAs: accountName(current) } : {}
+    };
+  }
+  if (options.signIn) {
+    const steps2 = [
+      ...installed.steps,
+      step3("Tailnet signed in", "running", { command: "tailscale up" })
+    ];
+    return { status: "installing", steps: steps2, signIn: options.signIn };
+  }
+  const steps = [
+    ...installed.steps,
+    step3("Tailnet signed in", "running", { command: "tailscale up" })
+  ];
+  onProgress(steps);
+  let accountUsername;
+  try {
+    accountUsername = userInfo().username;
+  } catch {
+  }
+  const operator = [options.operator, process.env.USER, accountUsername].find((candidate) => typeof candidate === "string" && /^[A-Za-z_][A-Za-z0-9_-]*$/u.test(candidate));
+  const upArgs = ["tailscale", "up", "--timeout=10s"];
+  if (operator)
+    upArgs.push(`--operator=${operator}`);
+  const getuid = options.getuid ?? process.getuid;
+  const root = getuid?.() === 0;
+  const up = platform === "linux" && !root ? await run2("sudo", ["-n", ...upArgs]) : await run2("tailscale", upArgs.slice(1));
+  const after = await readStatus(run2);
+  if (after?.BackendState === "Running") {
+    return {
+      status: "connected",
+      steps: [...installed.steps, step3("Tailnet signed in", "done")],
+      ...accountName(after) ? { signedInAs: accountName(after) } : {}
+    };
+  }
+  const output = `${up.stdout}
+${up.stderr}`;
+  const url = LOGIN_URL.exec(output)?.[0];
+  if (url) {
+    return {
+      status: "installing",
+      steps,
+      signIn: { method: "oauth", url, browserLocation: { kind: "none" } }
+    };
+  }
+  const reason = (up.stderr || up.stdout || "Tailscale could not start on this helper").trim();
+  return {
+    status: "error",
+    steps: [...installed.steps, step3("Tailnet signed in", "failed", { reason })],
+    errorMessage: reason
+  };
+}
+
 // apps/body/dist/squire-mcp-client.js
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 var INITIALIZE_TIMEOUT_MS = 3e4;
 var CALL_TIMEOUT_MS = 12e4;
@@ -17375,7 +17585,7 @@ var StdioSquireMcpClient = class {
   }
   initialize() {
     const launch = squireFacadeLaunch(homedir4());
-    const child = (this.options.spawn ?? spawn6)(this.options.command ?? launch.command, [...this.options.args ?? launch.args], { env: this.options.env ?? { ...squireConnectProcessEnv(), ...launch.env } });
+    const child = (this.options.spawn ?? spawn7)(this.options.command ?? launch.command, [...this.options.args ?? launch.args], { env: this.options.env ?? { ...squireConnectProcessEnv(), ...launch.env } });
     this.child = child;
     this.buffer = "";
     child.stdout.setEncoding("utf8");
@@ -17467,6 +17677,7 @@ var ConnectorAssignmentLoop = class {
   log;
   install;
   installGoogle;
+  installTailscale;
   googleHomeDir;
   readVaultFn;
   revokeGrantsFn;
@@ -17475,6 +17686,8 @@ var ConnectorAssignmentLoop = class {
   timer;
   /** Armed only while this helper owns a live sign-in ceremony. */
   connectWatch;
+  /** Armed only while a Tailscale browser login is waiting for its callback. */
+  tailscaleWatch;
   started = false;
   stopped = false;
   /** One install at a time per connector; other polls skip it. */
@@ -17493,6 +17706,7 @@ var ConnectorAssignmentLoop = class {
       onProgress,
       resolvedCredentials: sharedCredentials ? sharedCredentials() : this.resolveGoogleCredentials()
     }));
+    this.installTailscale = options.installTailscale ?? installTailscale;
     this.googleHomeDir = options.googleHome ?? process.env.BEELINE_AGENT_HOME ?? process.cwd();
     this.readVaultFn = options.readVault ?? readVault;
     this.revokeGrantsFn = options.revokeGrants ?? revokeGrants;
@@ -17526,6 +17740,10 @@ var ConnectorAssignmentLoop = class {
       this.cancel(this.connectWatch);
       this.connectWatch = void 0;
     }
+    if (this.tailscaleWatch !== void 0) {
+      this.cancel(this.tailscaleWatch);
+      this.tailscaleWatch = void 0;
+    }
   }
   /**
    * Watch the sign-in this helper is holding open. The phone paints
@@ -17638,12 +17856,57 @@ var ConnectorAssignmentLoop = class {
   }
   async handle(assignment) {
     if (assignment.kind === "install") {
-      await this.runInstall(assignment.connectorId);
-    } else if (assignment.kind === "sync")
+      if (assignment.connectorType === "tailscale") {
+        await this.runTailscaleInstall(assignment.connectorId);
+      } else {
+        await this.runInstall(assignment.connectorId);
+      }
+    } else if (assignment.kind === "sync" && assignment.connectorType !== "tailscale") {
       await this.runSync();
-    else if (assignment.kind === "revoke-grants")
+    } else if (assignment.kind === "revoke-grants")
       await this.runRevoke(assignment.connectorId, assignment.reference);
   }
+  /** Install Tailscale and publish its browser login URL until the tailnet is connected. */
+  async runTailscaleInstall(connectorId) {
+    const report = async (steps) => {
+      try {
+        await this.api.execute("postConnectorStatus", { agentId: this.agentId, connectorId, steps });
+      } catch (error) {
+        this.log(`step report failed: ${describe2(error)}`);
+      }
+    };
+    const existing = await this.connectorRow(connectorId);
+    const result = await this.installTailscale({
+      onProgress: report,
+      ...existing?.signIn ? { signIn: existing.signIn } : {}
+    });
+    if (result.status === "connected") {
+      if (this.tailscaleWatch !== void 0) {
+        this.cancel(this.tailscaleWatch);
+        this.tailscaleWatch = void 0;
+      }
+      await this.api.execute("installConnector", {
+        agentId: this.agentId,
+        connectorId,
+        ...result.signedInAs ? { signedInAs: result.signedInAs } : {}
+      });
+      return;
+    }
+    await this.api.execute("postConnectorStatus", {
+      agentId: this.agentId,
+      connectorId,
+      steps: result.steps,
+      signIn: result.status === "installing" ? result.signIn : null,
+      ...result.status === "error" ? { errorMessage: result.errorMessage } : {}
+    });
+    if (result.status === "installing" && this.tailscaleWatch === void 0) {
+      this.tailscaleWatch = this.schedule(() => {
+        this.tailscaleWatch = void 0;
+        if (!this.stopped)
+          void this.runOnce();
+      }, CONNECT_WATCH_INTERVAL_MS);
+    }
+  }
   /** Google tool connectors keep their manual credentials next to the runtime. */
   googleHome() {
     return this.googleHomeDir;
@@ -17761,7 +18024,7 @@ var ConnectorAssignmentLoop = class {
     const status = await this.connectorRow(connectorId);
     if (!status)
       return false;
-    return status.steps.length > 0 && status.steps.every((step3) => step3.status === "pending");
+    return status.steps.length > 0 && status.steps.every((step4) => step4.status === "pending");
   }
   /** One vault report covers every live trusty-squire connector on this helper. */
   async runSync() {
@@ -17797,7 +18060,7 @@ function isAgentCommand(value) {
     "reason"
   ].every((key) => typeof c2[key] === "string" && c2[key].length > 0))
     return false;
-  if (!["input", "resume", "stop"].includes(String(c2.action)) || !Number.isInteger(c2.agentDepth) || Number(c2.agentDepth) < 0 || Number(c2.agentDepth) > 3)
+  if (!["input", "resume", "stop", "restart"].includes(String(c2.action)) || !Number.isInteger(c2.agentDepth) || Number(c2.agentDepth) < 0 || Number(c2.agentDepth) > 3)
     return false;
   const source = c2.source;
   return Boolean(source && typeof source.id === "string" && typeof source.authorId === "string" && typeof source.body === "string" && typeof source.createdAt === "number" && Array.isArray(source.attachments));
@@ -17929,7 +18192,7 @@ function hiccupBackoffMs(attempt) {
 
 // apps/body/dist/daemon-api-client.js
 import { resolve as resolve9 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -17944,12 +18207,12 @@ var wrapper_default = import_websocket.default;
 
 // apps/body/dist/runtime.js
 import { randomBytes as randomBytes5 } from "node:crypto";
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { closeSync, openSync, readFileSync as readFileSync5 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile2, readdir, rename as rename2, stat, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname6, resolve as resolve8 } from "node:path";
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import { promisify } from "node:util";
 
 // node_modules/@noble/hashes/_u64.js
@@ -22336,7 +22599,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join5(separator = "") {
+function join6(separator = "") {
   astr("join", separator);
   return {
     encode: (from) => {
@@ -22466,8 +22729,8 @@ var base64 = hasBase64Builtin ? {
   decode(s) {
     return decodeBase64Builtin(s, false);
   }
-} : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join5(""));
-var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join5(""));
+} : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join6(""));
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join6(""));
 var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
 function bech32Polymod(pre) {
   const b = pre >> 25;
@@ -26072,13 +26335,13 @@ var NegentropyStorageVector = class {
     let count = last - first;
     while (count > 0) {
       let it = first;
-      let step3 = Math.floor(count / 2);
-      it += step3;
+      let step4 = Math.floor(count / 2);
+      it += step4;
       if (cmp(arr[it])) {
         first = ++it;
-        count -= step3 + 1;
+        count -= step4 + 1;
       } else {
-        count = step3;
+        count = step4;
       }
     }
     return first;
@@ -26480,7 +26743,7 @@ function decodeNsec(nsec) {
 }
 
 // apps/body/dist/runtime.js
-var execFileAsync = promisify(execFile2);
+var execFileAsync = promisify(execFile3);
 var DEFAULT_AGENT_IDENTITY_NAME = "beeline-agent";
 var DEFAULT_BODY_IDENTITY_NAME = "beeline-body";
 var DEFAULT_DAEMON_MONOLITH_BASE_URL = "https://server.usebeeline.app";
@@ -26728,7 +26991,7 @@ async function launchRuntimeDaemon(configPath, opts = {}) {
   const entrypoint = opts.entrypoint ?? process.argv[1];
   if (!entrypoint)
     throw new Error("cannot resolve daemon CLI entrypoint");
-  const child = spawn7(process.execPath, [...opts.execArgv ?? [], entrypoint, "daemon", "--config", resolve8(configPath)], {
+  const child = spawn8(process.execPath, [...opts.execArgv ?? [], entrypoint, "daemon", "--config", resolve8(configPath)], {
     cwd: directory,
     env: opts.env ?? process.env,
     detached: !foreground,
@@ -26789,7 +27052,7 @@ var DaemonApiClient = class {
   agentId;
   fetchImpl;
   webSocketFactory;
-  presenceLifecycleId = randomUUID2();
+  presenceLifecycleId = randomUUID3();
   liveSocket;
   liveReconnect;
   liveReconnectDelayMs = 1e3;
@@ -27058,15 +27321,15 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 }
 
 // apps/body/dist/room-runtime.js
-import { execFile as execFile7 } from "node:child_process";
+import { execFile as execFile8 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
-import { mkdir as mkdir15, rm as rm5 } from "node:fs/promises";
+import { mkdir as mkdir15, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname13, resolve as resolve24 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // apps/body/dist/grant-runner.js
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash3, randomBytes as randomBytes6 } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -27115,6 +27378,18 @@ function commandGrantMatches(rule, requested) {
   return rule.argv.every((word, index) => requested[index] === word);
 }
 var DECISION_LINE = new RegExp(`^(.+?) (approved once|approved|declined) (${AGENT_GRANT_KINDS.join("|")}) (.+)$`, "s");
+function parseGrantDecisionLine(body) {
+  const match = DECISION_LINE.exec(body);
+  if (!match)
+    return void 0;
+  const decision2 = match[2] === "approved once" ? "once" : match[2] === "approved" ? "always" : "deny";
+  return {
+    deciderName: match[1],
+    decision: decision2,
+    kind: match[3],
+    target: match[4]
+  };
+}
 var AGENT_GRANT_ESCALATION_REASONS = {
   "unseen-script": "it runs a script whose contents nobody has read",
   credential: "it names a credential or environment file"
@@ -27734,7 +28009,7 @@ var GrantCommandRunner = class {
     const sandboxMarker = runsOnHost ? void 0 : `[beeline-sandbox-started:${randomBytes6(16).toString("hex")}]`;
     const spawn13 = runsOnHost ? { command: argv[0], args: argv.slice(1) } : roomSandboxCommand(policy, room.cwd, argv, sandboxMarker);
     const outcome = await new Promise((resolveRun) => {
-      const child = execFile3(spawn13.command, spawn13.args, {
+      const child = execFile4(spawn13.command, spawn13.args, {
         cwd: room.cwd,
         env,
         timeout: this.options.timeoutMs ?? GRANT_COMMAND_TIMEOUT_MS,
@@ -28030,16 +28305,16 @@ function captureConnectionUsage(recorder, turn, calls) {
 }
 
 // apps/body/dist/server-command-intake.js
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname9, join as join6 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname9, join as join7 } from "node:path";
 var CommandExecutionContext = class {
-  generationId = randomUUID3();
+  generationId = randomUUID4();
   path;
   current;
   constructor(root) {
-    this.path = join6(root ?? tmpdir3(), `beeline-command-${this.generationId}.json`);
+    this.path = join7(root ?? tmpdir4(), `beeline-command-${this.generationId}.json`);
   }
   async enter(command) {
     this.current = command;
@@ -28130,7 +28405,9 @@ async function runServerCommandIntake(options) {
         return;
       for (const command of [...pending.values()]) {
         validateServerCommand(command, roomId, agentId);
-        if (busy && command.action !== "stop")
+        if (busy && command.action !== "stop" && command.action !== "restart")
+          continue;
+        if ((command.action === "input" || command.action === "resume") && options.canStartTurn?.() === false)
           continue;
         pending.delete(command.id);
         claimed.add(command.id);
@@ -28145,7 +28422,11 @@ async function runServerCommandIntake(options) {
           options.onError?.(error);
           continue;
         }
-        if (command.action === "stop") {
+        if (command.action === "restart") {
+          if (!options.restart)
+            throw new Error("restart command is not supported by this helper");
+          options.restart(command);
+        } else if (command.action === "stop") {
           options.stop(command.turnRequestId);
           await api.execute("acknowledgeAgentCommand", {
             roomId,
@@ -28177,7 +28458,7 @@ async function runServerCommandIntake(options) {
         wake = done;
         const timer = setTimeout(() => done(true), pushIntakeAcknowledged ? 6e4 : options.pollMs ?? 1e3);
         signal?.addEventListener("abort", aborted, { once: true });
-        if (pending.size && !busy)
+        if (!busy && [...pending.values()].some((command) => command.action === "stop" || command.action === "restart" || options.canStartTurn?.() !== false))
           done(false);
       });
       if (signal?.aborted)
@@ -28196,11 +28477,11 @@ async function runServerCommandIntake(options) {
 }
 
 // apps/body/dist/monolith-corner-turn.js
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { mkdir as mkdir14 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // apps/body/dist/agent-home.js
@@ -29002,10 +29283,10 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // apps/body/dist/agent-home.js
-import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
-import { chmod as chmod3, copyFile, lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir2, realpath, rename as rename3, rm as rm2, symlink, unlink as unlink3, writeFile as writeFile7 } from "node:fs/promises";
+import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
+import { chmod as chmod3, copyFile, lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir2, realpath, rename as rename3, rm as rm3, symlink, unlink as unlink3, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { basename as basename5, dirname as dirname10, join as join8, relative as relative2, resolve as resolve16, sep } from "node:path";
+import { basename as basename5, dirname as dirname10, join as join9, relative as relative2, resolve as resolve16, sep } from "node:path";
 
 // apps/body/dist/beeline-skill.js
 import { readFileSync as readFileSync6 } from "node:fs";
@@ -29017,6 +29298,7 @@ var MESSAGE_REACTION_EMOJIS = ["\u{1F44D}", "\u2764\uFE0F", "\u{1F602}", "\u{1F3
 // packages/api-contract/dist/workbench.js
 var CONNECTABLE_CONNECTOR_KINDS = [
   "trusty-squire",
+  "tailscale",
   "google-gmail",
   "google-calendar",
   "google-drive",
@@ -29138,7 +29420,7 @@ When your corner's pull request is ready, merging is your step: once the configu
 
 A **tool** is something you can use once a human adds it; a **key** is the credential that tool holds for that human. You spend a key through the mounted connector and never see the credential itself.
 
-The tools this build knows, what each is for, and which the person you are answering already has are one call away: beeline-agent workbench_status. Trusty Squire is vaulted credentials plus a browser that signs up and signs in for you; the Google tools (Gmail, Calendar, Drive, YouTube) work through the person's own Google sign-in \u2014 the same Workbench overlay, never a second Google window. YouTube Analytics answers only the channel owner account, not a manager. The wallet is created only from the Workbench page, and Tailscale is not available yet.
+The tools this build knows, what each is for, and which the person you are answering already has are one call away: beeline-agent workbench_status. Trusty Squire is vaulted credentials plus a browser that signs up and signs in for you; the Google tools (Gmail, Calendar, Drive, YouTube) work through the person's own Google sign-in \u2014 the same Workbench overlay, never a second Google window. YouTube Analytics answers only the channel owner account, not a manager. Tailscale installs its CLI on the selected helper and opens Tailscale's own browser sign-in; once connected, use the CLI for tailnet resources and tailscale file cp or tailscale file get for Taildrop. The wallet is created only from the Workbench page.
 
 **Offer the tool at the moment you need it.** When the work in front of you needs a tool the person does not have, do not send them to a settings page and do not stop at naming it. Call workbench_status first - a tool they already have is used, not offered. Then call offer_connector with the connectorType and one short reason: a card appears in this Room, spoken by you, addressed to the person you are answering, with one action. Only that person or a Workspace admin can accept it; accepting adds the tool on your machine, and the sign-in or keys stay theirs. Your turn pauses on the card - say in prose what you are waiting for and end the turn; you are woken when it is added, and then you carry on.
 
@@ -29395,7 +29677,7 @@ function stringArray(value) {
 }
 
 // apps/body/dist/host-mcp-route.js
-import { join as join7, resolve as resolve14 } from "node:path";
+import { join as join8, resolve as resolve14 } from "node:path";
 var import_yaml = __toESM(require_dist(), 1);
 function grantedMcpServerNames(grants) {
   const names = /* @__PURE__ */ new Set();
@@ -29412,18 +29694,33 @@ function ungatedHostServers(hostServers, granted) {
   const allowed = new Set(granted);
   return hostServers.filter((name) => !allowed.has(name));
 }
-function grantedHostRoutesFromList(result) {
+async function claimGrantedHostRoutes(result, consumeOnce) {
   if (!result || typeof result !== "object" || !("grants" in result))
     return [];
   const grants = result.grants;
   if (!Array.isArray(grants))
     return [];
-  return grantedMcpServerNames(grants.flatMap((entry) => {
+  const mounted = [];
+  for (const entry of grants) {
     if (!entry || typeof entry !== "object")
-      return [];
-    const row = entry;
-    return typeof row.kind === "string" && typeof row.target === "string" ? [{ kind: row.kind, target: row.target }] : [];
-  }));
+      continue;
+    const grant = entry;
+    if (grant.kind !== "mcp" || typeof grant.target !== "string")
+      continue;
+    if (grant.status === "once") {
+      if (typeof grant.grantId !== "string" || !grant.grantId)
+        continue;
+      try {
+        await consumeOnce(grant.grantId);
+      } catch {
+        continue;
+      }
+    } else if (grant.status !== "approved") {
+      continue;
+    }
+    mounted.push({ kind: "mcp", target: grant.target });
+  }
+  return grantedMcpServerNames(mounted);
 }
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -29446,7 +29743,7 @@ function grantedSquireHostRoute(granted, declarations = {}) {
   });
 }
 function hostRouteEnv(hostHome) {
-  return { XDG_CONFIG_HOME: join7(resolve14(hostHome), ".config") };
+  return { XDG_CONFIG_HOME: join8(resolve14(hostHome), ".config") };
 }
 function rewriteHostMcpDeclaration(name, declaration, hostHome) {
   const next = { ...declaration };
@@ -30630,7 +30927,7 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, op
   const plan = await planManagedSkills(managedSkills, sharedSkills, optionalShares);
   if (await materializedSkillManifest(target) === plan.manifest)
     return;
-  const staged = resolve16(parent, `.skills.${process.pid}.${randomUUID4()}.tmp`);
+  const staged = resolve16(parent, `.skills.${process.pid}.${randomUUID5()}.tmp`);
   await mkdir6(staged, { mode: 448 });
   try {
     for (const entry of plan.entries) {
@@ -30644,10 +30941,10 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, op
     }
     const existing = await lstat2(target).catch(() => void 0);
     if (existing)
-      await rm2(target, { recursive: existing.isDirectory(), force: true });
+      await rm3(target, { recursive: existing.isDirectory(), force: true });
     await rename3(staged, target);
   } finally {
-    await rm2(staged, { recursive: true, force: true });
+    await rm3(staged, { recursive: true, force: true });
   }
 }
 async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
@@ -30666,8 +30963,8 @@ async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
     try {
       const tree = [];
       await walkSafeSkillTree(shared.source, shared.source, {
-        directory: async (rel) => void tree.push(`d ${join8(shared.name, rel)}`),
-        file: async (rel, realPath) => void tree.push(`f ${join8(shared.name, rel)} ${sha2563(await readFile6(realPath))}`)
+        directory: async (rel) => void tree.push(`d ${join9(shared.name, rel)}`),
+        file: async (rel, realPath) => void tree.push(`f ${join9(shared.name, rel)} ${sha2563(await readFile6(realPath))}`)
       });
       entries.push({ kind: "shared", name: shared.name, source: shared.source });
       lines.push(...tree);
@@ -30687,7 +30984,7 @@ async function materializedSkillManifest(target) {
   const visit = async (directory, prefix) => {
     for (const entry of await readdir2(directory)) {
       const path = resolve16(directory, entry);
-      const rel = prefix ? join8(prefix, entry) : entry;
+      const rel = prefix ? join9(prefix, entry) : entry;
       const entryStats = await lstat2(path);
       if (entryStats.isSymbolicLink())
         return false;
@@ -30855,7 +31152,7 @@ async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
     for (const entry of await readdir2(resolvedSource)) {
       if (entry === "." || entry === "..")
         throw new Error("invalid shared skill entry");
-      await walkSafeSkillTree(resolve16(source, entry), sourceRoot, visitor, rel ? join8(rel, entry) : entry);
+      await walkSafeSkillTree(resolve16(source, entry), sourceRoot, visitor, rel ? join9(rel, entry) : entry);
     }
     return;
   }
@@ -30882,7 +31179,7 @@ async function writeIsolatedHarnessFile(path, content) {
   if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
     throw new Error(`isolated harness parent is not a real directory: ${parent}`);
   }
-  const temporary = resolve16(parent, `.${basename5(path)}.${process.pid}.${randomUUID4()}.tmp`);
+  const temporary = resolve16(parent, `.${basename5(path)}.${process.pid}.${randomUUID5()}.tmp`);
   try {
     await writeFile7(temporary, content, { mode: 384, flag: "wx" });
     await chmod3(temporary, 384);
@@ -30941,7 +31238,7 @@ function agentCommandCatalogPublisher(input) {
 
 // apps/body/dist/attachment-delivery.js
 import { mkdir as mkdir7, writeFile as writeFile8 } from "node:fs/promises";
-import { basename as basename6, extname, join as join9 } from "node:path";
+import { basename as basename6, extname, join as join10 } from "node:path";
 var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 var EXPIRED_REASON = "expired: these attachment bytes are past their retention window";
 var FETCH_TIMEOUT_MS = 3e4;
@@ -31000,7 +31297,7 @@ async function deliverAttachments(attachments, dir, fetchImpl = fetch) {
         return { attachment, reason: EXPIRED_REASON };
       if (!fetched.ok)
         throw new Error(`HTTP ${fetched.status}`);
-      const path = join9(dir, safeFileName(attachment, index, taken));
+      const path = join10(dir, safeFileName(attachment, index, taken));
       await writeFile8(path, fetched.bytes);
       const bytes = fetched.bytes;
       const mimeType = attachment.mimeType ?? fetched.mimeType;
@@ -31580,14 +31877,18 @@ export default async function (pi) {
         label: labelOf(tool.name),
         description: typeof tool.description === 'string' ? tool.description : tool.name,
         parameters: schema,
-        async execute(_toolCallId, params, signal) {
+        async execute(toolCallId, params, signal) {
           const result = await callServer(
             server,
             {
               jsonrpc: '2.0',
               id: 1,
               method: 'tools/call',
-              params: { name: tool.name, arguments: params ?? {} },
+              params: {
+                name: tool.name,
+                arguments: params ?? {},
+                _meta: { beelineToolCallId: toolCallId },
+              },
             },
             signal,
           );
@@ -31604,9 +31905,9 @@ export default async function (pi) {
 `;
 
 // apps/body/dist/corner-branch-sync.js
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile4);
+var execFileAsync2 = promisify2(execFile5);
 async function syncCornerBranch(input) {
   const git = input.git ?? (async (args) => (await execFileAsync2("git", ["-C", input.worktreePath, ...args], {
     ...input.env ? { env: input.env } : {},
@@ -32082,6 +32383,7 @@ function beelineAgentMcpServer(config, api, context) {
       { name: "BEELINE_DAEMON_ROOM_ID", value: context.roomId },
       { name: "BEELINE_DAEMON_WORKSPACE_ID", value: context.workspaceId },
       ...context.cornerId ? [{ name: "BEELINE_DAEMON_CORNER_ID", value: context.cornerId }] : [],
+      ...context.agentMayCloseCorner ? [{ name: "BEELINE_CORNER_AGENT_CLOSE", value: "1" }] : [],
       ...context.reviewer ? [{ name: "BEELINE_CORNER_REVIEWER", value: "1" }] : [],
       ...context.attachRoot ? [{ name: "BEELINE_ATTACH_ROOT", value: context.attachRoot }] : [],
       ...context.attachScratchRoot ? [{ name: "BEELINE_ATTACH_SCRATCH_ROOT", value: context.attachScratchRoot }] : [],
@@ -32128,11 +32430,11 @@ function youtubeMcpServer(config, accessToken) {
 }
 
 // apps/body/dist/codegraph.js
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { access, appendFile, mkdir as mkdir9, readFile as readFile7 } from "node:fs/promises";
 import { dirname as dirname11, isAbsolute as isAbsolute3, resolve as resolve19 } from "node:path";
 import { promisify as promisify3 } from "node:util";
-var execFileAsync3 = promisify3(execFile5);
+var execFileAsync3 = promisify3(execFile6);
 var CODEGRAPH_MCP_SERVER_NAME = "codegraph";
 var CODEGRAPH_INDEX_PATH = ".codegraph/codegraph.db";
 var CODEGRAPH_PREPARE_TIMEOUT_MS = 12e4;
@@ -32433,7 +32735,7 @@ async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
 }
 
 // apps/body/dist/turn-trace.js
-import { appendFile as appendFile2, mkdir as mkdir10, readdir as readdir4, rm as rm3 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10, readdir as readdir4, rm as rm4 } from "node:fs/promises";
 import { resolve as resolve21 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 var TURN_PHASES = [
@@ -32705,7 +33007,7 @@ var TurnTraceFile = class {
     this.prunedDay = day;
     const cutoff = traceFileName(new Date(now2.getTime() - TURN_TRACE_RETENTION_DAYS * 864e5));
     const names = await readdir4(this.directory).catch(() => []);
-    await Promise.all(names.filter((name) => /^turns-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name < cutoff).map((name) => rm3(resolve21(this.directory, name), { force: true })));
+    await Promise.all(names.filter((name) => /^turns-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name < cutoff).map((name) => rm4(resolve21(this.directory, name), { force: true })));
   }
 };
 
@@ -32864,10 +33166,10 @@ process.exit(result.status ?? 1);
 }
 
 // apps/body/dist/warm-node-modules.js
-import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { chmod as chmod5, copyFile as copyFile2, link, lstat as lstat3, mkdir as mkdir12, readdir as readdir5, readFile as readFile9, readlink, rename as rename4, rm as rm4, stat as stat2, symlink as symlink2, utimes } from "node:fs/promises";
-import { dirname as dirname12, join as join10, resolve as resolve23 } from "node:path";
+import { chmod as chmod5, copyFile as copyFile2, link, lstat as lstat3, mkdir as mkdir12, readdir as readdir5, readFile as readFile9, readlink, rename as rename4, rm as rm5, stat as stat2, symlink as symlink2, utimes } from "node:fs/promises";
+import { dirname as dirname12, join as join11, resolve as resolve23 } from "node:path";
 var STORE_FORMAT = "v1";
 var STAGING_PREFIX = ".beeline-warm-";
 var STAGING_SWEEP_MS = 24 * 60 * 60 * 1e3;
@@ -32935,7 +33237,7 @@ async function seedWarmNodeModules(input) {
   if (storeDevice === void 0 || storeDevice !== checkoutDevice) {
     return { reason: "cross-device", key: plan.key };
   }
-  const staging = resolve23(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID5()}`);
+  const staging = resolve23(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID6()}`);
   const placed = [];
   const now2 = (input.now ?? Date.now)();
   try {
@@ -32953,11 +33255,11 @@ async function seedWarmNodeModules(input) {
     return { reason: "seeded", key: plan.key };
   } catch (error) {
     for (const target of placed) {
-      await rm4(target, { recursive: true, force: true }).catch(() => void 0);
+      await rm5(target, { recursive: true, force: true }).catch(() => void 0);
     }
     return { reason: "failed", key: plan.key, detail: describe3(error) };
   } finally {
-    await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function harvestWarmNodeModules(input) {
@@ -32981,7 +33283,7 @@ async function harvestWarmNodeModules(input) {
       detail: `${missing.length} absent, e.g. ${missing.slice(0, 3).join(", ")}`
     };
   }
-  const staging = resolve23(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID5()}`);
+  const staging = resolve23(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID6()}`);
   try {
     await mkdir12(input.storeRoot, { recursive: true, mode: 493 });
     await sweepStaleStaging(input.storeRoot, (input.now ?? Date.now)());
@@ -33000,14 +33302,14 @@ async function harvestWarmNodeModules(input) {
       return { reason: "already-warm", key: plan.key };
     return { reason: "failed", key: plan.key, detail: describe3(error) };
   } finally {
-    await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(staging, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function stagedTreeIsPublishable(worktreePath, staging, key) {
   const settled = await readWarmPlan(worktreePath);
   if (isPlanRefusal(settled) || settled.key !== key)
     return false;
-  const hidden = join10("node_modules", ".package-lock.json");
+  const hidden = join11("node_modules", ".package-lock.json");
   const [copied, current] = await Promise.all([
     readFile9(resolve23(staging, hidden)).catch(() => void 0),
     readFile9(resolve23(worktreePath, hidden)).catch(() => void 0)
@@ -33045,7 +33347,7 @@ async function missingInstalledPackages(worktreePath, treeRoot = worktreePath) {
   return missing.sort();
 }
 async function isInstalledPackage(path) {
-  return stat2(join10(path, "package.json")).then((info) => info.isFile(), () => false);
+  return stat2(join11(path, "package.json")).then((info) => info.isFile(), () => false);
 }
 var INTEGRITY_READ_CONCURRENCY = 64;
 async function mapWithLimit(values, limit, visit) {
@@ -33079,8 +33381,8 @@ function isContainedTreePath(value) {
 async function cloneTree(source, target, file, topLevel = true) {
   await mkdir12(target, { recursive: true, mode: 493 });
   for (const entry of await readdir5(source, { withFileTypes: true })) {
-    const from = join10(source, entry.name);
-    const to = join10(target, entry.name);
+    const from = join11(source, entry.name);
+    const to = join11(target, entry.name);
     if (entry.isSymbolicLink()) {
       await symlink2(await readlink(from), to);
       continue;
@@ -33110,13 +33412,13 @@ async function pruneWarmStore(storeRoot, keep) {
   const names = (await readdir5(storeRoot).catch(() => [])).filter((name) => !name.startsWith(STAGING_PREFIX));
   const entries = [];
   for (const name of names) {
-    const info = await lstat3(join10(storeRoot, name)).catch(() => void 0);
+    const info = await lstat3(join11(storeRoot, name)).catch(() => void 0);
     if (info?.isDirectory())
       entries.push({ name, usedAt: info.mtimeMs });
   }
   const dropped = entries.sort((a2, b) => b.usedAt - a2.usedAt || a2.name.localeCompare(b.name)).slice(keep);
   for (const entry of dropped) {
-    await rm4(join10(storeRoot, entry.name), { recursive: true, force: true }).catch(() => void 0);
+    await rm5(join11(storeRoot, entry.name), { recursive: true, force: true }).catch(() => void 0);
   }
   return dropped.map((entry) => entry.name);
 }
@@ -33125,11 +33427,11 @@ async function sweepStaleStaging(storeRoot, now2) {
   for (const name of entries) {
     if (!name.startsWith(STAGING_PREFIX))
       continue;
-    const path = join10(storeRoot, name);
+    const path = join11(storeRoot, name);
     const info = await lstat3(path).catch(() => void 0);
     if (!info || now2 - info.mtimeMs < STAGING_SWEEP_MS)
       continue;
-    await rm4(path, { recursive: true, force: true }).catch(() => void 0);
+    await rm5(path, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function pathExists(path) {
@@ -33148,7 +33450,7 @@ function describe3(error) {
 // apps/body/dist/monolith-room-turn.js
 import { mkdir as mkdir13 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // packages/api-contract/dist/scheduled-prompts.js
 var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
@@ -33192,6 +33494,14 @@ function resumePrompt(item) {
       'Acknowledge in one short line (for example "Adding Trusty Squire now.") and continue the work that needed it, or say plainly what still has to happen before you can.'
     ].join(" ");
   }
+  const grant = parseGrantDecisionLine(item.body);
+  if (grant?.kind === "mcp" && grant.decision !== "deny") {
+    return [
+      "This is the answer to your grant request; your paused work resumes now.",
+      `The approved ${grant.target} route is mounted in this session.`,
+      "Continue the paused work with that tool now; do not restart, schedule another turn, or request the route again."
+    ].join(" ");
+  }
   return [
     "This is the answer to your grant request; your paused work resumes now.",
     "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
@@ -33367,7 +33677,7 @@ var MonolithRoomTurnLoop = class {
     const cached = this.deliveredAttachments.get(item.id);
     if (cached)
       return cached;
-    const delivered = await deliverAttachments(item.attachments, join11(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
+    const delivered = await deliverAttachments(item.attachments, join12(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
     this.deliveredAttachments.set(item.id, withoutImageData(delivered));
     return delivered;
   }
@@ -33424,9 +33734,10 @@ var MonolithRoomTurnLoop = class {
   }
   async grantedHostRoutes() {
     try {
-      return grantedHostRoutesFromList(await this.options.api.execute("listAgentGrants", {
-        agentId: this.agent.publicKey
-      }));
+      return claimGrantedHostRoutes(await this.options.api.execute("listAgentGrants", {
+        agentId: this.agent.publicKey,
+        roomId: this.options.roomId
+      }), (grantId) => this.options.api.execute("consumeAgentGrant", { grantId }));
     } catch {
       return [];
     }
@@ -33487,7 +33798,7 @@ var MonolithRoomTurnLoop = class {
       args: this.options.config.agentArgs ?? []
     }, selection);
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join11(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join12(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     this.sessionStateDirs = stateDirs;
     const homeStateDirs = harnessHomeStateDirs(harnessLabel, agentEnv.HOME ?? operatorHome);
@@ -33976,6 +34287,8 @@ ${JSON.stringify((corners.corners ?? []).filter((corner) => !corner.archived))}`
         onPoll: () => this.options.health.poll(),
         onError: (error) => console.error("[thin-core] Room command failed", error),
         stop: (requestId) => this.stopTurn(requestId),
+        restart: () => this.options.onRestartRequested?.(),
+        canStartTurn: this.options.canStartTurn,
         run: async (command) => {
           const item = {
             ...command.source,
@@ -34009,7 +34322,7 @@ function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsI
 }
 
 // apps/body/dist/monolith-corner-turn.js
-var execFileAsync4 = promisify4(execFile6);
+var execFileAsync4 = promisify4(execFile7);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
@@ -34026,6 +34339,8 @@ function cornerReviewerInstruction(input) {
   const headSha = input.headSha ?? "<head sha>";
   return `Checks are green on PR #${number} at ${headSha}. Review it now with the beeline-review skill against that exact head. FAIL: reply \`@${author}\` with the confirmed findings to fix. PASS: call the approve_merge tool for ${headSha}, then reply \`@${author} approved ${headSha}, merge\`. Never merge yourself. Never say you are holding or waiting for checks.`;
 }
+var CORNER_REVIEWER_SESSION_INSTRUCTION = "You are this Room's configured reviewer. The active turn prompt names the latest stable green PR head. Review and approve only that exact head; if no stable green head is named, end the turn without a verdict. Never merge yourself.";
+var CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION = "There is no stable green PR head for this active reviewer turn. Do not review or call approve_merge. End this turn without a verdict; the next green transition will wake you.";
 function cornerSelfReviewerInstruction(input) {
   if (!input.reviewerHandle || !input.agentHandle || !input.openedByAgent || input.agentHandle.replace(/^@/, "") !== input.reviewerHandle.replace(/^@/, ""))
     return void 0;
@@ -34247,6 +34562,8 @@ var MonolithCornerTurnLoop = class {
   yoloMode = false;
   /** The live parent-Room reviewer baked into the current session. */
   reviewerHandle;
+  /** Identity-only reviewer context; the exact PR head is refreshed inside each active turn. */
+  reviewerInstructionInput;
   /** The role-specific second-chance instruction for this session. */
   cornerTurnEndNudge = CORNER_DELIVERY_NUDGE;
   /** Repository state already given a delivery reminder, until that state changes. */
@@ -34392,9 +34709,10 @@ var MonolithCornerTurnLoop = class {
   }
   async grantedHostRoutes() {
     try {
-      return grantedHostRoutesFromList(await this.options.api.execute("listAgentGrants", {
-        agentId: this.agent.publicKey
-      }));
+      return claimGrantedHostRoutes(await this.options.api.execute("listAgentGrants", {
+        agentId: this.agent.publicKey,
+        roomId: this.options.cornerId
+      }), (grantId) => this.options.api.execute("consumeAgentGrant", { grantId }));
     } catch {
       return [];
     }
@@ -34421,17 +34739,8 @@ var MonolithCornerTurnLoop = class {
       authorHandle: opener?.handle,
       openedByAgent: !this.options.openedBy || this.options.openedBy === this.agent.publicKey
     };
-    let reviewerInstruction = cornerReviewerInstruction(reviewerInput);
-    if (reviewerInstruction) {
-      const restore = await this.options.api.execute("getCornerRestoreState", {
-        cornerId: this.options.cornerId
-      });
-      reviewerInstruction = cornerReviewerInstruction({
-        ...reviewerInput,
-        pullRequestNumber: restore.lifecycle?.pr?.number,
-        headSha: restore.lifecycle?.pr?.headSha
-      });
-    }
+    const reviewerInstruction = cornerReviewerInstruction(reviewerInput) ? CORNER_REVIEWER_SESSION_INSTRUCTION : void 0;
+    this.reviewerInstructionInput = reviewerInstruction ? reviewerInput : void 0;
     const selfReviewerInstruction = cornerSelfReviewerInstruction(reviewerInput);
     this.cornerTurnEndNudge = reviewerInstruction ?? selfReviewerInstruction ?? cornerMergeInstruction(configuration.yoloMode, configuration.reviewerHandle);
     await mkdir14(this.options.worktreePath, { recursive: true });
@@ -34490,7 +34799,7 @@ var MonolithCornerTurnLoop = class {
       args: this.options.config.agentArgs ?? []
     }, selection);
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join12(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join13(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     const homeStateDirs = harnessHomeStateDirs(harnessLabel, agentEnv.HOME ?? operatorHome);
     await Promise.all(homeStateDirs.map((dir) => mkdir14(dir, { recursive: true })));
@@ -34579,6 +34888,7 @@ var MonolithCornerTurnLoop = class {
         roomId: this.options.parentRoomId,
         workspaceId: this.options.workspaceId,
         cornerId: this.options.cornerId,
+        agentMayCloseCorner: Boolean(repository),
         reviewer: Boolean(reviewerInstruction),
         attachRoot: this.options.worktreePath,
         // The whole per-session overlay, not an enumerated subset: see
@@ -34636,10 +34946,9 @@ var MonolithCornerTurnLoop = class {
           "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then post_artifact with the path to send them back to the corner.",
           "Do not initialize a repository, create a branch, commit, push, open a pull request, or wait for GitHub checks.",
           // This lane has no pull request URL and no merge card, so its
-          // attached final reply is the requester-facing completion
-          // signal. close_corner is still the lifecycle completion: it
-          // archives the corner and reaps this scratch workspace.
-          this.options.requesterHandle ? `Deliver the result as artifacts: post_artifact everything the objective asked for, then call close_corner. Finish the turn by replying with @${this.options.requesterHandle} and one line on what you posted; that attached reply is the requester-facing completion signal.` : `Deliver the result as artifacts: post_artifact everything the objective asked for, then call close_corner. Finish the turn by replying with one line on what you posted; that attached reply is the requester-facing completion signal.`
+          // attached final reply reports delivery to the requester. The
+          // corner remains open until a human explicitly closes it.
+          this.options.requesterHandle ? `Deliver the result as artifacts: post_artifact everything the objective asked for. Finish the turn by replying with @${this.options.requesterHandle} and one line on what you posted. The corner stays open until a human explicitly closes it.` : `Deliver the result as artifacts: post_artifact everything the objective asked for. Finish the turn by replying with one line on what you posted. The corner stays open until a human explicitly closes it.`
         ]
       ].filter(Boolean).join("\n\n")
     });
@@ -34652,6 +34961,41 @@ var MonolithCornerTurnLoop = class {
     }
     return opened.sessionId;
   }
+  /**
+   * Resolve the review target at prompt time, not session activation time.
+   *
+   * A push can land after a reviewer session starts but before its first
+   * prompt, or while that prompt is running. The active prompt and its bounded
+   * second pass therefore each read the current green lifecycle head. The
+   * server still compares approve_merge's SHA with the current head, so a push
+   * after this read fails closed too.
+   */
+  async activeReviewerInstruction() {
+    const input = this.reviewerInstructionInput;
+    if (!input)
+      return void 0;
+    try {
+      const [restore, localHead] = await Promise.all([
+        this.options.api.execute("getCornerRestoreState", {
+          cornerId: this.options.cornerId
+        }),
+        execFileAsync4("git", ["-C", this.options.worktreePath, "rev-parse", "HEAD"]).then(({ stdout: stdout6 }) => stdout6.trim())
+      ]);
+      const pr = restore.lifecycle?.pr;
+      if (restore.lifecycle?.checks !== "passing" || !pr?.number || !pr.headSha || pr.headSha !== localHead)
+        return CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION;
+      return [
+        "Current stable reviewer target for this active turn; it supersedes any older head in the trigger or transcript:",
+        cornerReviewerInstruction({
+          ...input,
+          pullRequestNumber: pr.number,
+          headSha: pr.headSha
+        })
+      ].join("\n");
+    } catch {
+      return CORNER_REVIEWER_UNSTABLE_HEAD_INSTRUCTION;
+    }
+  }
   /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
   lifecycle(trace) {
     return {
@@ -34757,10 +35101,11 @@ var MonolithCornerTurnLoop = class {
             throw new Error("corner turn stopped for daemon handoff");
           this.busy = true;
           await this.syncBranch();
-          const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
+          const [conversation, roster, delivered, activeReviewerInstruction] = await trace.measure("context-fetch", () => Promise.all([
             api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join12(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join13(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([]),
+            this.activeReviewerInstruction()
           ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
           const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
@@ -34779,13 +35124,14 @@ var MonolithCornerTurnLoop = class {
 ${this.options.objective}`,
             WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
             roomMentionDirectory(roster, this.agent.publicKey),
+            activeReviewerInstruction,
             [
               ...sourceMessageId ? [`Reaction target message id: ${sourceMessageId}`] : [],
               `Newest trigger:
 ${trigger}`,
               ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
             ].join("\n"),
-            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
+            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files; only a human can close this corner.",
             MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
@@ -34926,7 +35272,9 @@ ${trigger}`,
               this.lastDeliveryNudgeState = deliveryState;
             replyBeforeNudge = durableReplyText(result.agentText);
             await flushToolCalls(result.toolCalls, "");
-            result = await runPrompt(this.reviewerHandle ? this.cornerTurnEndNudge : checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
+            if (this.reviewerInstructionInput)
+              await this.syncBranch();
+            result = await runPrompt(this.reviewerHandle ? await this.activeReviewerInstruction() ?? this.cornerTurnEndNudge : checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
             trace.promptSettled();
             explained = await this.explainEmpty(result);
           }
@@ -35063,6 +35411,8 @@ ${trigger}`,
         onPoll: () => this.options.onPoll(),
         onError: (error) => console.error("[thin-core] corner command failed", error),
         stop: (requestId) => this.stopTurn(requestId),
+        restart: () => this.options.onRestartRequested?.(),
+        canStartTurn: this.options.canStartTurn,
         closed: async () => {
           if (this.closePushed) {
             this.closePushed = false;
@@ -35543,6 +35893,10 @@ var DiscoveryWakes = class {
 function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
   return isOpener && !restore.featureBranch && !restore.lifecycle?.branch && !restore.lifecycle?.pr;
 }
+function cornerBranchIsSafeToDelete(lifecycle) {
+  const pr = lifecycle?.pr;
+  return !pr || Boolean(pr.mergedAt);
+}
 function cornerStartConfigKey(repository, objective) {
   return JSON.stringify({
     resolution: repository.resolution,
@@ -35583,7 +35937,7 @@ async function materializeCornerWorktree(input) {
     `+refs/heads/${input.featureBranch}:refs/remotes/origin/${input.featureBranch}`
   ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 }).then(() => true, () => false);
   if (!existsSync6(resolve24(path, ".git"))) {
-    await rm5(path, { recursive: true, force: true });
+    await rm6(path, { recursive: true, force: true });
     await execFileAsync5("git", [
       `--git-dir=${gitCommonDir}`,
       "worktree",
@@ -35651,7 +36005,8 @@ async function mapWithConcurrency(values, limit, visit) {
     }
   }));
 }
-async function removeCornerWorktreeAndBranches(worktree) {
+async function removeCornerWorktreeAndBranches(worktree, options = {}) {
+  const preserveRemoteBranch = options.preserveRemoteBranch === true;
   const localRef = `refs/heads/${worktree.branch}`;
   const remoteRef = `refs/heads/${worktree.branch}`;
   const worktreeExists = existsSync6(worktree.path);
@@ -35675,6 +36030,8 @@ async function removeCornerWorktreeAndBranches(worktree) {
       worktree.path
     ]);
   } else if (!localExists) {
+    if (preserveRemoteBranch)
+      return;
     await deleteExactRemoteBranch(worktree.gitCommonDir, remoteRef, worktree.token, {
       requireAbsent: true
     });
@@ -35685,7 +36042,9 @@ async function removeCornerWorktreeAndBranches(worktree) {
       throw new Error(`refusing to delete repository HEAD ${localRef}`);
     }
   }
-  await deleteExactRemoteBranch(worktree.gitCommonDir, remoteRef, worktree.token);
+  if (!preserveRemoteBranch) {
+    await deleteExactRemoteBranch(worktree.gitCommonDir, remoteRef, worktree.token);
+  }
   if (await gitRefExists(worktree.gitCommonDir, localRef)) {
     await execFileAsync5("git", [
       `--git-dir=${worktree.gitCommonDir}`,
@@ -35697,13 +36056,13 @@ async function removeCornerWorktreeAndBranches(worktree) {
     ]);
   }
 }
-var execFileAsync5 = promisify5(execFile7);
+var execFileAsync5 = promisify5(execFile8);
 async function removeCornerScratchWorkspace(input) {
   const expected = resolve24(input.roomRoot, "scratch");
   if (resolve24(input.scratchPath) !== expected) {
     throw new Error(`refusing to remove scratch outside corner ${input.cornerId}`);
   }
-  await rm5(expected, { recursive: true, force: true });
+  await rm6(expected, { recursive: true, force: true });
 }
 var RoomRuntimeCoordinator = class {
   configPath;
@@ -35743,6 +36102,7 @@ var RoomRuntimeCoordinator = class {
   workspaceRemovalConfirmations = 0;
   roomRemovalConfirmations = /* @__PURE__ */ new Map();
   confirmationPending = false;
+  restartRequested = false;
   /** Unscoped agent-directed discovery wakes (#1369), counted instead of
    *  flagged: a wake that arrives while a reconcile is already running must
    *  survive its start-pass clearing, or a reconnect mid-reconcile waits a
@@ -35784,6 +36144,7 @@ var RoomRuntimeCoordinator = class {
     });
     this.options.daemonApi.setConfigChangedListener?.(() => {
       void this.scheduler.suspendIdle().catch((error) => console.error("[body] config-change session restart failed", error));
+      void Promise.resolve(this.options.onConfigChanged?.()).catch((error) => console.error("[body] config-change catalog refresh failed", error));
     });
     this.options.daemonApi.setHiccupRestartListener?.((attempt) => {
       this.options.onHiccupRestart?.(attempt);
@@ -35834,6 +36195,12 @@ var RoomRuntimeCoordinator = class {
         count += 1;
     return count;
   }
+  requestLifecycleRestart() {
+    if (this.restartRequested)
+      return;
+    this.restartRequested = true;
+    this.options.onRestartRequested?.();
+  }
   quiesceForUpdateIfIdle() {
     if (!this.isWorkspaceIdle())
       return false;
@@ -36093,7 +36460,9 @@ var RoomRuntimeCoordinator = class {
       },
       onCornerOpened: () => {
         this.confirmationPending = true;
-      }
+      },
+      onRestartRequested: () => this.requestLifecycleRestart(),
+      canStartTurn: () => !this.restartRequested
     });
     const promise = loop.run().catch((error) => {
       if (!controller.signal.aborted)
@@ -36245,7 +36614,9 @@ var RoomRuntimeCoordinator = class {
           branch: featureBranch,
           parentRoomId: corner.parentRoomId,
           token: ""
-        }) : this.reapCornerScratch({ path: workspacePath, cornerId: corner.cornerId })
+        }) : this.reapCornerScratch({ path: workspacePath, cornerId: corner.cornerId }),
+        onRestartRequested: () => this.requestLifecycleRestart(),
+        canStartTurn: () => !this.restartRequested
       });
       const promise = loop.run().catch((error) => {
         if (!controller.signal.aborted) {
@@ -36351,25 +36722,44 @@ var RoomRuntimeCoordinator = class {
   }
   async reapCornerWorktree(worktree) {
     try {
+      const preserveRemoteBranch = !await this.cornerBranchMayBeDeleted(worktree.cornerId);
       const parentRoomId = worktree.parentRoomId;
-      if (!parentRoomId) {
+      if (!parentRoomId && !preserveRemoteBranch) {
         throw new Error(`corner ${worktree.cornerId} has no parent Room for GitHub token`);
       }
-      const token = (await this.options.daemonApi.execute("getRoomGitHubToken", { roomId: parentRoomId })).token;
-      await removeCornerWorktreeAndBranches({ ...worktree, token });
-      await this.options.daemonApi.execute("postCornerRemoteState", {
-        cornerId: worktree.cornerId,
-        branch: worktree.branch,
-        state: "gone",
-        checks: "unknown"
-      });
+      const token = preserveRemoteBranch ? "" : (await this.options.daemonApi.execute("getRoomGitHubToken", {
+        roomId: parentRoomId
+      })).token;
+      await removeCornerWorktreeAndBranches({ ...worktree, token }, { preserveRemoteBranch });
       this.pendingCornerReaps.delete(worktree.cornerId);
+      if (!preserveRemoteBranch) {
+        await this.options.daemonApi.execute("postCornerRemoteState", {
+          cornerId: worktree.cornerId,
+          branch: worktree.branch,
+          state: "gone",
+          checks: "unknown"
+        });
+      }
     } catch (error) {
       this.pendingCornerReaps.set(worktree.cornerId, { ...worktree, token: "" });
       this.confirmationPending = true;
       throw error;
     }
   }
+  /**
+   * Whether a corner's feature branch is safe to delete on teardown. A read
+   * that fails — an agent removed from the corner, or a corner a helper can no
+   * longer reach — is not proof its pull request is gone, so the branch is
+   * kept.
+   */
+  async cornerBranchMayBeDeleted(cornerId) {
+    try {
+      const state = await this.options.daemonApi.execute("getCornerRestoreState", { cornerId });
+      return cornerBranchIsSafeToDelete(state.lifecycle);
+    } catch {
+      return false;
+    }
+  }
   async reapCornerScratch(scratch) {
     await removeCornerScratchWorkspace({
       cornerId: scratch.cornerId,
@@ -36608,13 +36998,13 @@ import { mkdir as mkdir17, rename as rename5 } from "node:fs/promises";
 import { dirname as dirname15, resolve as resolve26 } from "node:path";
 
 // apps/body/dist/systemd.js
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import { mkdir as mkdir16, readFile as readFile10, stat as stat3, writeFile as writeFile10 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import { dirname as dirname14, resolve as resolve25 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify6 } from "node:util";
-var execFileAsync6 = promisify6(execFile8);
+var execFileAsync6 = promisify6(execFile9);
 var DELIBERATE_REMOVAL_EXIT_STATUS = 78;
 var DAEMON_DISTRESS_EXIT_STATUS = 77;
 var UNKNOWN_AGENT_EXIT_STATUS = 79;
@@ -36883,8 +37273,8 @@ init_self_update_manifest();
 
 // apps/body/dist/managed-update.js
 init_self_update();
-import { spawn as spawn9 } from "node:child_process";
-import { mkdir as mkdir20, rm as rm7, stat as stat4, writeFile as writeFile13 } from "node:fs/promises";
+import { spawn as spawn10 } from "node:child_process";
+import { mkdir as mkdir20, rm as rm8, stat as stat4, writeFile as writeFile13 } from "node:fs/promises";
 import { dirname as dirname18, resolve as resolve29 } from "node:path";
 
 // apps/body/dist/update-rollback-alert.js
@@ -36977,7 +37367,7 @@ ${now2()}
         throw error;
       const age = now2() - await stat4(lock).then((value) => value.mtimeMs).catch(() => now2());
       if (age > LOCK_STALE_MS) {
-        await rm7(lock, { recursive: true, force: true });
+        await rm8(lock, { recursive: true, force: true });
         continue;
       }
       if (now2() >= deadline)
@@ -36988,7 +37378,7 @@ ${now2()}
   try {
     return await work();
   } finally {
-    await rm7(lock, { recursive: true, force: true });
+    await rm8(lock, { recursive: true, force: true });
   }
 }
 var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
@@ -37298,7 +37688,7 @@ async function runManagedUpdateWorkerProcess() {
   if (!entrypoint)
     throw new Error("cannot resolve the current Beeline entrypoint");
   await new Promise((resolveWorker, rejectWorker) => {
-    const child = spawn9(process.execPath, [entrypoint, "managed-update-worker"], {
+    const child = spawn10(process.execPath, [entrypoint, "managed-update-worker"], {
       detached: true,
       env: { ...process.env, BEELINE_INTERNAL_UPDATE_WORKER: "1" },
       stdio: ["ignore", "pipe", "pipe"]
@@ -37457,6 +37847,32 @@ async function rollbackFailedSuccessor(layout, runtimeDir, cause = {}) {
 }
 
 // apps/body/dist/self-update-cli.js
+async function refreshRuntimeHarnessAdapters(options = {}) {
+  const log2 = options.log ?? console.log;
+  const readRuntime = options.readRuntime ?? readRuntimeRecord;
+  const install = options.install ?? ((command) => runAdapterInstall(command));
+  const configPaths = options.configPaths ?? [
+    ...await findRuntimeConfigPaths(process.cwd()).catch(() => []),
+    ...await findAgentRuntimeConfigPaths(process.env, process.cwd()).catch(() => [])
+  ];
+  const kinds = /* @__PURE__ */ new Set();
+  for (const path of new Set(configPaths)) {
+    const runtime = await readRuntime(path).catch(() => void 0);
+    if (runtime?.agentKind)
+      kinds.add(runtime.agentKind);
+  }
+  for (const kind of kinds) {
+    const command = latestAdapterInstallCommand(kind);
+    if (!command)
+      continue;
+    log2(`[beeline] refreshing ${kind} adapter: ${formatAdapterInstallCommand(command)}`);
+    try {
+      await install(command);
+    } catch (error) {
+      log2(`[beeline] ${kind} adapter refresh failed; keeping the installed copy (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+}
 function updateUsage() {
   console.log(`
 ${import_picocolors.default.bold("Update the installed Beeline bundle from the published manifest.")}
@@ -37558,6 +37974,8 @@ async function runUpdateCommand(args) {
     await printStatus(layout);
     return;
   }
+  if (!checkOnly)
+    await refreshRuntimeHarnessAdapters();
   const installed = await readInstalledBundleIdentity(layout);
   console.log(`[beeline] installed bundle: ${describeIdentity(installed)}`);
   const raw = await fetch(manifestUrl, { signal: AbortSignal.timeout(3e4) }).then((response) => {
@@ -37724,7 +38142,7 @@ async function runStartCommand(args, interactiveUi, dependencyOverrides = {}) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn11 } from "node:child_process";
-import { createHash as createHash9, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID7 } from "node:crypto";
 import { chmod as chmod7, mkdir as mkdir21, readFile as readFile13, unlink as unlink5, writeFile as writeFile14 } from "node:fs/promises";
 import { homedir as homedir13, hostname as hostname2 } from "node:os";
 import { dirname as dirname20, resolve as resolve30 } from "node:path";
@@ -37811,14 +38229,13 @@ async function verifyProviderKey(input) {
 }
 
 // apps/body/dist/pair-agent-selection.js
-import { spawn as spawn10 } from "node:child_process";
 import { stdin as stdin2, stdout as stdout3 } from "node:process";
 var NO_AGENT_MESSAGE = `No supported ACP-capable coding agent was detected.
 Install one of these supported agents:
-  codex  npm install -g @openai/codex @agentclientprotocol/codex-acp
-  claude Install Claude Code and npm install -g @agentclientprotocol/claude-agent-acp
+  codex  npm install -g @openai/codex@latest @agentclientprotocol/codex-acp@latest
+  claude Install Claude Code and npm install -g @agentclientprotocol/claude-agent-acp@latest
   goose  https://block.github.io/goose/docs/getting-started/installation/
-  pi     npm install -g @mariozechner/pi-coding-agent pi-acp
+  pi     npm install -g @mariozechner/pi-coding-agent@latest pi-acp@latest
   grok   curl -fsSL https://x.ai/cli/install.sh | bash
   cursor Install Cursor Agent CLI from https://cursor.com/docs/cli
 Then retry, or explicitly use \`--agent reference\` with an LLM key.
@@ -37839,21 +38256,7 @@ async function clackSelectAgent(candidates) {
   return unwrapPrompt(picked, "Pairing cancelled.");
 }
 async function installAdapter(install, opts) {
-  await new Promise((resolveInstall, rejectInstall) => {
-    const child = spawn10(install.command, install.args, {
-      cwd: opts.cwd,
-      env: opts.env ?? process.env,
-      stdio: "inherit"
-    });
-    child.once("error", rejectInstall);
-    child.once("exit", (code, signal) => {
-      if (code === 0)
-        resolveInstall();
-      else {
-        rejectInstall(new Error(signal ? `${install.command} was terminated by ${signal}` : `${install.command} exited with status ${code ?? "unknown"}`));
-      }
-    });
-  });
+  await runAdapterInstall(install, opts);
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -37867,14 +38270,38 @@ async function selectPairAgentCommand(opts) {
   const selectAgent = opts.selectAgent ?? clackSelectAgent;
   const confirmInstall = opts.confirmInstall ?? clackConfirmInstall;
   const runInstall = opts.install ?? installAdapter;
+  const useReadyAgent = async (agent, label) => {
+    const refresh = latestAdapterInstallCommand(agent.kind);
+    if (!refresh) {
+      output.write(`[beeline] using ${agent.kind} (${label})
+`);
+      return agent;
+    }
+    output.write(`[beeline] refreshing ${agent.kind} adapter: ${formatAdapterInstallCommand(refresh)}
+`);
+    try {
+      await runInstall(refresh, { cwd: opts.cwd, env: opts.env });
+      const refreshed = resolveAgentCommand({
+        kind: agent.kind,
+        env: opts.env,
+        cwd: opts.cwd
+      });
+      output.write(`[beeline] using ${refreshed.kind} (${label}; adapter current)
+`);
+      return refreshed;
+    } catch (installError) {
+      throw new Error(`Could not refresh the ${agent.kind} adapter: ${errorMessage(installError)}. Install it with: ${formatAdapterInstallCommand(refresh)}`);
+    }
+  };
   if (opts.explicitKind !== void 0) {
     try {
-      return resolveAgentCommand({
+      const selected = resolveAgentCommand({
         kind: opts.explicitKind,
         customCommand: opts.customCommand,
         env: opts.env,
         cwd: opts.cwd
       });
+      return await useReadyAgent(selected, "selected");
     } catch (resolutionError) {
       const candidate = detectInstalledAgentCommands({ env: opts.env, cwd: opts.cwd }).find((detected2) => detected2.kind === opts.explicitKind && detected2.status === "missing-adapter");
       if (!candidate || candidate.status !== "missing-adapter")
@@ -37920,25 +38347,19 @@ async function selectPairAgentCommand(opts) {
       throw new Error("Installed coding agents need ACP adapter setup; install an adapter above, then retry.");
     }
     if (ready.length === 1) {
-      output.write(`[beeline] using ${ready[0].kind} (auto-detected)
-`);
-      return ready[0].agent;
+      return useReadyAgent(ready[0].agent, "auto-detected");
     }
     const readyKinds = ready.map((candidate) => candidate.kind).join(", ");
     throw new Error(`Detected multiple ACP-capable coding agents: ${readyKinds}. This session is non-interactive; pass \`--agent <name>\` explicitly.`);
   }
   if (detected.length === 1 && detected[0].status === "ready") {
-    output.write(`[beeline] using ${detected[0].kind} (auto-detected)
-`);
-    return detected[0].agent;
+    return useReadyAgent(detected[0].agent, "auto-detected");
   }
   while (true) {
     const pickedKind = await selectAgent(detected);
     const selected = detected.find((candidate) => candidate.kind === pickedKind);
     if (selected.status === "ready") {
-      output.write(`[beeline] using ${selected.kind} (selected)
-`);
-      return selected.agent;
+      return useReadyAgent(selected.agent, "selected");
     }
     const manual = missingAdapterMessage(selected);
     output.write(`[beeline] installing ${selected.kind} adapter: ${formatAdapterInstallCommand(selected.install)}
@@ -38157,10 +38578,23 @@ function connectModelPickerFromAxes(axes, fallbackModel, harness, rawAxes = axes
     note: `${harness} did not enumerate models; offering the provider default`
   };
 }
-async function loadConnectModelCatalog(input) {
-  const agent = resolveAgentCommand({ kind: input.harness });
+var refreshedConnectAdapters = /* @__PURE__ */ new Map();
+function refreshConnectAdapter(kind) {
+  const existing = refreshedConnectAdapters.get(kind);
+  if (existing)
+    return existing;
+  const refresh = installLatestAgentAdapter(kind).catch((error) => {
+    refreshedConnectAdapters.delete(kind);
+    throw error;
+  });
+  refreshedConnectAdapters.set(kind, refresh);
+  return refresh;
+}
+async function loadConnectModelCatalog(input, dependencies = {}) {
+  await (dependencies.refreshAdapter ?? refreshConnectAdapter)(input.harness);
+  const agent = (dependencies.resolveAgent ?? ((kind) => resolveAgentCommand({ kind })))(input.harness);
   const model = input.model ?? defaultConnectModel(input.harness, input.provider);
-  const catalog = await fetchAgentModelCatalog(agent, providerEnvironment({
+  const catalog = await (dependencies.fetchCatalog ?? fetchAgentModelCatalog)(agent, providerEnvironment({
     harness: input.harness,
     ...input.provider ? { provider: input.provider } : {},
     ...input.apiKey ? { apiKey: input.apiKey } : {},
@@ -38211,8 +38645,6 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
     return (picked ?? "").trim();
   };
   const askEffort = async (catalog2, forHarness, model2, forProvider, forKey) => {
-    if (!catalog2.effort)
-      return void 0;
     let axis = catalog2.effort;
     if (model2 !== catalog2.currentValue) {
       const reread = await loadModels({
@@ -38224,7 +38656,7 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
       }).catch(() => void 0);
       axis = reread?.effort ?? axis;
     }
-    if (!axis.options.length)
+    if (!axis?.options.length)
       return void 0;
     const picked = await prompts.select({
       message: brass("Choose reasoning effort"),
@@ -38368,7 +38800,7 @@ async function readMachineId(env = process.env) {
     if (!/^[0-9a-f-]{32,}$/.test(machineId))
       throw new Error("invalid persisted machine id");
   } catch {
-    machineId = randomUUID6();
+    machineId = randomUUID7();
     try {
       await mkdir21(configDir, { recursive: true, mode: 448 });
       await writeFile14(machineIdPath, `${machineId}
@@ -38648,7 +39080,7 @@ async function runConnectFinishCommand(path) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir22, readFile as readFile14, rename as rename8, rm as rm8, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir22, readFile as readFile14, rename as rename8, rm as rm9, writeFile as writeFile15 } from "node:fs/promises";
 import { dirname as dirname21, resolve as resolve31 } from "node:path";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
@@ -38688,11 +39120,11 @@ async function recordDaemonStartFailure(runtimeDir, error, now2 = Date.now()) {
   return { distressed, count: failures.length, path: daemonFailurePath(runtimeDir) };
 }
 async function clearDaemonStartFailures(runtimeDir) {
-  await rm8(daemonFailurePath(runtimeDir), { force: true });
+  await rm9(daemonFailurePath(runtimeDir), { force: true });
 }
 
 // apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir23, rm as rm9 } from "node:fs/promises";
+import { mkdir as mkdir23, rm as rm10 } from "node:fs/promises";
 import { homedir as homedir14 } from "node:os";
 import { resolve as resolve32 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
@@ -38817,7 +39249,7 @@ async function runUpdateFunctionalProbe(input) {
   const root = input.probeRoot ?? resolve32(input.runtimeDir, "update-functional-probe");
   const cwd = resolve32(root, "checkout");
   const homeRoot = resolve32(root, "agent-home");
-  await rm9(root, { recursive: true, force: true });
+  await rm10(root, { recursive: true, force: true });
   await mkdir23(cwd, { recursive: true, mode: 448 });
   let client;
   try {
@@ -38992,13 +39424,13 @@ async function runUpdateFunctionalProbe(input) {
     };
   } finally {
     await client?.stop().catch(() => void 0);
-    await rm9(root, { recursive: true, force: true }).catch(() => void 0);
+    await rm10(root, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 
 // apps/body/dist/current-release-probe.js
 import { spawn as spawn12 } from "node:child_process";
-import { dirname as dirname22, join as join14 } from "node:path";
+import { dirname as dirname22, join as join15 } from "node:path";
 init_self_update();
 var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 12e4;
 var UPDATE_PROBE_COMMAND = "update-probe";
@@ -39041,7 +39473,7 @@ function outcomeFromReport(report) {
   }
 }
 async function probeReleaseInSubprocess(input) {
-  const bundleDir = join14(input.layout.releasesRoot, input.releaseId);
+  const bundleDir = join15(input.layout.releasesRoot, input.releaseId);
   const entrypoint = await resolveBundleEntrypoint(bundleDir);
   if (!entrypoint) {
     return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
@@ -39104,7 +39536,7 @@ async function runUpdateProbeCommand(args, options = {}) {
   const runtime = await readRuntimeRecord(configPath);
   const agent = runtimeAgentCommand(runtime);
   const config = loadBodyConfig({
-    workspaceRoot: join14(dirname22(configPath), "workspace"),
+    workspaceRoot: join15(dirname22(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env: { ...env, BUZZ_AGENT_BIN: agent.command, BUZZ_DEV_MCP_BIN: runtime.mcpBinary },
     agent
@@ -39130,7 +39562,7 @@ async function runUpdateProbeCommand(args, options = {}) {
     sandboxRequired: runtime.sandbox !== "off",
     sandboxUnavailableDetail: sandbox.advisory,
     // The successor's probe still holds `<runtimeDir>/update-functional-probe`.
-    probeRoot: join14(runtimeDir, "current-release-probe")
+    probeRoot: join15(runtimeDir, "current-release-probe")
   }));
   const report = outcome.kind === "served" ? { probe: "served" } : outcome.kind === "refused" ? { probe: "refused", status: outcome.status, reason: outcome.reason } : outcome.kind === "sandbox-unavailable" ? { probe: "sandbox-unavailable", reason: outcome.reason } : { probe: "failed", reason: outcome.reason };
   write(JSON.stringify(report));
@@ -39303,6 +39735,21 @@ async function runStoredDaemon(pathOrPointer) {
     throw new Error("monolith daemon transport activation failed");
   runtime = activated.runtime;
   const daemonApi = activated.client;
+  const refreshRuntimeAdapter = async () => {
+    const kind = runtime.agentKind;
+    if (!kind)
+      return;
+    const install = latestAdapterInstallCommand(kind);
+    if (!install)
+      return;
+    console.log(`[body] refreshing ${kind} adapter: ${formatAdapterInstallCommand(install)}`);
+    await installLatestAgentAdapter(kind);
+  };
+  try {
+    await refreshRuntimeAdapter();
+  } catch (error) {
+    console.error(`[body] adapter refresh failed; validating the installed copy (${error instanceof Error ? error.message : String(error)})`);
+  }
   const agent = runtimeAgentCommand(runtime);
   await writeDaemonPidRecord(configPath, process.pid);
   const env = {
@@ -39328,7 +39775,7 @@ async function runStoredDaemon(pathOrPointer) {
   if (runtime.sharedSkills)
     config.sharedSkills = [...runtime.sharedSkills];
   if (runtime.modelSelection) {
-    await applyRuntimeModelPreflight(config, agent, runtime.modelSelection);
+    await applyRuntimeModelPreflight(config, agent, runtime.modelSelection, void 0, refreshRuntimeAdapter);
     if (!config.modelUnavailable) {
       console.log("[body] persisted model/effort selection passed live startup validation");
     } else {
@@ -39394,10 +39841,28 @@ async function runStoredDaemon(pathOrPointer) {
   scratchSweepTimer.unref();
   let ready = false;
   let connectorLoop;
+  let catalogRefresh;
+  const refreshCatalog = () => {
+    catalogRefresh ??= syncAgentModelCatalog({
+      api: daemonApi,
+      agent,
+      agentEnv: config.agentEnv,
+      agentId: runtime.agent.publicKey,
+      workspaceId: runtime.communityId,
+      runtimeDir,
+      ...runtime.modelSelection ? { runtimeSelection: runtime.modelSelection } : {},
+      force: true
+    }).then(() => void 0).finally(() => {
+      catalogRefresh = void 0;
+    });
+    return catalogRefresh;
+  };
   let stoppingStatus = "daemon stopped";
   try {
+    let lifecycleRestartDrain;
     const core = new ThinDaemonCore(runtime, configPath, config, {
       daemonApi,
+      onConfigChanged: refreshCatalog,
       onHiccupRestart: (attempt) => {
         const delay = hiccupBackoffMs(attempt);
         console.warn(`[thin-core] hiccup restart attempt ${attempt}; exiting so systemd can start a fresh helper`);
@@ -39407,6 +39872,30 @@ async function runStoredDaemon(pathOrPointer) {
         }
         const timer = setTimeout(() => process.exit(0), delay);
         timer.unref?.();
+      },
+      onRestartRequested: () => {
+        if (lifecycleRestartDrain)
+          return;
+        const deadlineAt = Date.now() + DEFAULT_DRAIN_DEADLINE_MS;
+        stoppingStatus = `restart requested; active work draining; exit_deadline=${new Date(deadlineAt).toISOString()}`;
+        void notifier.progress(stoppingStatus);
+        core.setDrainDeadlineAt(deadlineAt);
+        lifecycleRestartDrain = (async () => {
+          while (core.activeTurnCount() > 0 && Date.now() < deadlineAt) {
+            await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+          }
+          const forced = core.activeTurnCount() > 0;
+          if (forced)
+            await core.prepareForForcedUpdateRestart();
+          else
+            core.quiesceForUpdateIfIdle();
+          stoppingStatus = forced ? "restart requested; drain deadline reached; active work cancelled" : "restart requested; active work drained";
+          await notifier.stopping(stoppingStatus);
+          controller.abort();
+        })().catch((error) => {
+          console.error("[thin-core] requested restart drain failed:", error);
+          controller.abort();
+        });
       }
     });
     const updateDrain = update ? new ManagedUpdateDrain({