usebeeline 0.0.33 → 0.0.34

package/dist/usebeeline.mjs

@@ -309,12 +309,12 @@ __export(self_update_exports, {
 });
 import { createHash as createHash2 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod as chmod2, lstat as lstat2, mkdir as mkdir7, open, readFile as readFile3, rename as rename3, rm as rm4, symlink as symlink2, writeFile as writeFile4 } from "node:fs/promises";
+import { access, chmod as chmod3, lstat as lstat2, mkdir as mkdir8, open, readFile as readFile4, rename as rename3, rm as rm4, symlink as symlink2, writeFile as writeFile5 } from "node:fs/promises";
 import { spawn as spawn4 } from "node:child_process";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join2, resolve as resolve13 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname8, join as join3, resolve as resolve14 } from "node:path";
 function anchorLayout(rawLibDir) {
-  const libDir = resolve13(rawLibDir);
+  const libDir = resolve14(rawLibDir);
   const segments = libDir.split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   if (idx >= 2 && segments[idx - 1] === "lib") {
@@ -330,9 +330,9 @@ function anchorLayout(rawLibDir) {
     // prefix's bin, NOT <prefix>/lib/bin — deriving it one level up was the
     // defect that made activateRelease write its stable forwarders where
     // nothing executed them, leaving stale raw wrappers in <prefix>/bin.
-    binDir: resolve13(libDir, "../../bin"),
+    binDir: resolve14(libDir, "../../bin"),
     libDir,
-    releasesRoot: resolve13(libDir, `../${RELEASES_SEGMENT}`)
+    releasesRoot: resolve14(libDir, `../${RELEASES_SEGMENT}`)
   };
 }
 function beelineInstallLayout(env = process.env) {
@@ -342,8 +342,8 @@ function beelineInstallLayout(env = process.env) {
   return anchorLayout(raw);
 }
 function defaultBeelineInstallLayout(env = process.env) {
-  const home = env.HOME?.trim() || homedir7();
-  return anchorLayout(resolve13(home, ".local", "lib", "beeline"));
+  const home = env.HOME?.trim() || homedir9();
+  return anchorLayout(resolve14(home, ".local", "lib", "beeline"));
 }
 function hostPlatformKey() {
   const os = process.platform === "linux" ? "linux" : process.platform === "darwin" ? "darwin" : "";
@@ -353,13 +353,13 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join2(bundleDir, "lib", "beeline", "bundle.json"), join2(bundleDir, "bundle.json")];
+  return [join3(bundleDir, "lib", "beeline", "bundle.json"), join3(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
   for (const candidate of bundleJsonCandidates(bundleDir)) {
     try {
-      raw = await readFile3(candidate, "utf8");
+      raw = await readFile4(candidate, "utf8");
       break;
     } catch {
     }
@@ -377,18 +377,18 @@ async function readBundleJson(bundleDir) {
   }
 }
 function updateStatePath(layout) {
-  return join2(layout.releasesRoot, ".state", "update-state.json");
+  return join3(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
-    return JSON.parse(await readFile3(updateStatePath(layout), "utf8"));
+    return JSON.parse(await readFile4(updateStatePath(layout), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir7(join2(layout.releasesRoot, ".state"), { recursive: true });
-  await writeFile4(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
+  await mkdir8(join3(layout.releasesRoot, ".state"), { recursive: true });
+  await writeFile5(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 async function readInstalledBundleIdentity(layout, _state = {}) {
@@ -469,7 +469,7 @@ function run(command, args, timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join2(bundleDir, BUNDLE_ENTRYPOINT), join2(bundleDir, "beeline-cli.mjs")];
+  return [join3(bundleDir, BUNDLE_ENTRYPOINT), join3(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
@@ -491,18 +491,18 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   const releaseId = sanitizeReleaseId(published.commit ?? published.version ?? `release-${Date.now()}`);
-  const releaseDir = join2(layout.releasesRoot, releaseId);
-  const okMarker = join2(releaseDir, ".stage-ok");
+  const releaseDir = join3(layout.releasesRoot, releaseId);
+  const okMarker = join3(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
-    const recorded = await readFile3(okMarker, "utf8");
+    const recorded = await readFile4(okMarker, "utf8");
     if (recorded.trim() === published.sha256)
       return releaseId;
     previouslyVerified = true;
   } catch {
   }
-  await mkdir7(releaseDir, { recursive: true });
-  const tempArchive = join2(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  await mkdir8(releaseDir, { recursive: true });
+  const tempArchive = join3(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
     log(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
@@ -522,7 +522,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (actual !== published.sha256.toLowerCase()) {
       throw new Error(`checksum mismatch for ${published.file}: expected ${published.sha256}, got ${actual} \u2014 aborting without touching the installed bundle`);
     }
-    await writeFile4(tempArchive, Buffer.concat(chunks), { mode: 384 });
+    await writeFile5(tempArchive, Buffer.concat(chunks), { mode: 384 });
     const entries = (await new Promise((resolveList, rejectList) => {
       const child = spawn4("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
       let out = "";
@@ -542,18 +542,18 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract2.stderr}`);
     for (const relative3 of requiredBundlePaths()) {
       try {
-        await access(join2(releaseDir, relative3), fsConstants.F_OK);
+        await access(join3(releaseDir, relative3), fsConstants.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative3}`);
       }
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join2(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
+      const probe = await run(process.execPath, [join3(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()}` : ""}`);
       }
     }
-    await writeFile4(okMarker, `${published.sha256}
+    await writeFile5(okMarker, `${published.sha256}
 `, "utf8");
     log(`staged release ${releaseId} (sha256 verified)`);
     return releaseId;
@@ -581,26 +581,26 @@ function forwarderScript(tool) {
 }
 async function replaceFile(path, contents, mode) {
   const temp = `${path}.new-${process.pid}`;
-  await writeFile4(temp, contents, { mode });
-  await chmod2(temp, mode);
+  await writeFile5(temp, contents, { mode });
+  await chmod3(temp, mode);
   await rename3(temp, path);
 }
 async function activateRelease(layout, releaseId) {
-  const releaseDir = join2(layout.releasesRoot, releaseId);
-  await access(join2(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
-  await mkdir7(layout.releasesRoot, { recursive: true });
-  await mkdir7(layout.binDir, { recursive: true });
+  const releaseDir = join3(layout.releasesRoot, releaseId);
+  await access(join3(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
+  await mkdir8(layout.releasesRoot, { recursive: true });
+  await mkdir8(layout.binDir, { recursive: true });
   let previousReleaseId = await activeReleaseId(layout);
   const kind = await pathKind(layout.libDir);
   if (kind === "directory") {
     const legacyIdentity = await readBundleJson(layout.libDir);
     const legacyId = sanitizeReleaseId(legacyIdentity?.commit ?? legacyIdentity?.version ?? `legacy-${Date.now()}`);
-    const legacyDir = join2(layout.releasesRoot, legacyId);
+    const legacyDir = join3(layout.releasesRoot, legacyId);
     try {
       await access(legacyDir, fsConstants.F_OK);
       previousReleaseId = `${legacyId}-${Date.now()}`;
-      await rename3(layout.libDir, join2(layout.releasesRoot, previousReleaseId));
-      await normalizeLegacyBundleShape(join2(layout.releasesRoot, previousReleaseId));
+      await rename3(layout.libDir, join3(layout.releasesRoot, previousReleaseId));
+      await normalizeLegacyBundleShape(join3(layout.releasesRoot, previousReleaseId));
     } catch {
       await rename3(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
@@ -609,18 +609,18 @@ async function activateRelease(layout, releaseId) {
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
   await rm4(tempLink, { force: true });
-  await symlink2(join2("beeline-releases", releaseId), tempLink);
+  await symlink2(join3("beeline-releases", releaseId), tempLink);
   await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname7(layout.libDir));
+  await fsyncDir(dirname8(layout.libDir));
   await writeBinForwarders(layout, releaseDir);
   return { previousReleaseId };
 }
 async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join2(bundleDir, "lib", "beeline");
+  const innerLib = join3(bundleDir, "lib", "beeline");
   let anyFlat = false;
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join2(bundleDir, name), fsConstants.F_OK);
+      await access(join3(bundleDir, name), fsConstants.F_OK);
       anyFlat = true;
       break;
     } catch {
@@ -628,62 +628,62 @@ async function normalizeLegacyBundleShape(bundleDir) {
   }
   if (!anyFlat)
     return;
-  await mkdir7(innerLib, { recursive: true });
+  await mkdir8(innerLib, { recursive: true });
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join2(innerLib, name), fsConstants.F_OK);
+      await access(join3(innerLib, name), fsConstants.F_OK);
       continue;
     } catch {
     }
-    await rename3(join2(bundleDir, name), join2(innerLib, name)).catch(() => void 0);
+    await rename3(join3(bundleDir, name), join3(innerLib, name)).catch(() => void 0);
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
   for (const tool of FORWARDER_TOOLS) {
-    const target = join2(activeBundleRoot, "bin", tool);
+    const target = join3(activeBundleRoot, "bin", tool);
     try {
       await access(target, fsConstants.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join2(layout.binDir, tool), forwarderScript(tool), 493);
+    await replaceFile(join3(layout.binDir, tool), forwarderScript(tool), 493);
   }
 }
 async function repairInstallForwarders(layout, opts = {}) {
   if (await pathKind(layout.libDir) !== "symlink")
     return false;
-  const forwarderPath = join2(layout.binDir, "beeline");
+  const forwarderPath = join3(layout.binDir, "beeline");
   let current;
   try {
-    current = await readFile3(forwarderPath, "utf8");
+    current = await readFile4(forwarderPath, "utf8");
   } catch {
     current = void 0;
   }
   if (current === forwarderScript("beeline"))
     return false;
-  await mkdir7(layout.binDir, { recursive: true });
+  await mkdir8(layout.binDir, { recursive: true });
   await writeBinForwarders(layout, layout.libDir);
   opts.logger?.(`[body] self-update: repaired <prefix>/bin forwarders to follow the active-bundle anchor (${layout.libDir})`);
   return true;
 }
 async function rollbackToPreviousRelease(layout, previousReleaseId) {
-  const releaseDir = join2(layout.releasesRoot, previousReleaseId);
+  const releaseDir = join3(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 rm4(tempLink, { force: true });
-  await symlink2(join2("beeline-releases", previousReleaseId), tempLink);
+  await symlink2(join3("beeline-releases", previousReleaseId), tempLink);
   await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname7(layout.libDir));
+  await fsyncDir(dirname8(layout.libDir));
 }
 function updateAttemptPath(layout) {
-  return join2(layout.releasesRoot, ".state", "update-attempt.json");
+  return join3(layout.releasesRoot, ".state", "update-attempt.json");
 }
 async function readUpdateAttempt(layout) {
   try {
-    const raw = JSON.parse(await readFile3(updateAttemptPath(layout), "utf8"));
+    const raw = JSON.parse(await readFile4(updateAttemptPath(layout), "utf8"));
     if (raw.version !== 1 || typeof raw.appliedAt !== "number" || typeof raw.confirmBy !== "number" || typeof raw.releaseId !== "string" || !["pending", "confirmed", "reverted"].includes(raw.status)) {
       return void 0;
     }
@@ -693,10 +693,10 @@ async function readUpdateAttempt(layout) {
   }
 }
 async function writeUpdateAttempt(layout, record2) {
-  await mkdir7(join2(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir8(join3(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateAttemptPath(layout);
   const staged = `${path}.${process.pid}.tmp`;
-  await writeFile4(staged, `${JSON.stringify(record2, null, 2)}
+  await writeFile5(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
   await rename3(staged, path);
 }
@@ -955,8 +955,8 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname12, resolve as resolve20 } from "node:path";
-import { readFile as readFile8, unlink as unlink3, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname13, resolve as resolve21 } from "node:path";
+import { readFile as readFile9, unlink as unlink3, writeFile as writeFile11 } from "node:fs/promises";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -2327,8 +2327,9 @@ import { accessSync as accessSync2, constants as constants2, existsSync as exist
 import { basename, dirname, resolve as resolve2 } from "node:path";
 
 // apps/body/dist/agent-command.js
-import { accessSync, constants, existsSync } from "node:fs";
-import { delimiter, isAbsolute, resolve } from "node:path";
+import { accessSync, constants, existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 var AGENT_KINDS = [
   "codex",
   "claude",
@@ -2363,13 +2364,74 @@ var ADAPTER_INSTALL_COMMANDS = {
 function adapterInstallHint(kind) {
   return formatAdapterInstallCommand(ADAPTER_INSTALL_COMMANDS[kind]);
 }
+function nodeVersionRank(name) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(name);
+  if (!match)
+    return void 0;
+  return [Number(match[1] ?? 0), Number(match[2] ?? 0), Number(match[3] ?? 0)];
+}
+function nodeVersionBins(versionsDir, binSuffix) {
+  let entries;
+  try {
+    entries = readdirSync(versionsDir);
+  } catch {
+    return [];
+  }
+  return entries.map((name) => ({ name, rank: nodeVersionRank(name) })).filter((entry) => Boolean(entry.rank)).sort((a2, b) => {
+    for (let i3 = 0; i3 < 3; i3 += 1) {
+      const delta = (b.rank[i3] ?? 0) - (a2.rank[i3] ?? 0);
+      if (delta !== 0)
+        return delta;
+    }
+    return 0;
+  }).map((entry) => join(versionsDir, entry.name, binSuffix));
+}
+function wellKnownExecutableDirs(env = process.env) {
+  const home = env.HOME?.trim() || homedir();
+  const xdgData = env.XDG_DATA_HOME?.trim() || resolve(home, ".local", "share");
+  const fnmRoots = [
+    env.FNM_DIR?.trim(),
+    resolve(xdgData, "fnm"),
+    resolve(home, ".fnm")
+  ].filter((root) => Boolean(root));
+  const nvmRoots = [env.NVM_DIR?.trim(), resolve(home, ".nvm")].filter((root) => Boolean(root));
+  const versioned = [];
+  for (const root of fnmRoots) {
+    versioned.push(...nodeVersionBins(join(root, "node-versions"), "installation/bin"));
+  }
+  for (const root of nvmRoots) {
+    versioned.push(...nodeVersionBins(join(root, "versions", "node"), "bin"));
+  }
+  return [
+    ...versioned,
+    resolve(home, ".local", "bin"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin"
+  ];
+}
+function augmentedSearchDirectories(env = process.env) {
+  const directories = [];
+  const pushAll = (paths) => {
+    for (const directory of paths) {
+      if (directory && !directories.includes(directory))
+        directories.push(directory);
+    }
+  };
+  pushAll((env.PATH ?? "").split(delimiter));
+  if (env.BEELINE_HARNESS_PATH_AUGMENT === "0")
+    return directories;
+  pushAll(wellKnownExecutableDirs(env));
+  pushAll((env.BEELINE_LAUNCHER_PATH ?? "").split(delimiter));
+  return directories;
+}
+function describeExecutableSearch(env = process.env) {
+  return augmentedSearchDirectories(env).join(", ");
+}
 function firstExisting(paths) {
   return paths.find((path) => path && existsSync(path));
 }
 function executableOnPath(name, env = process.env) {
-  for (const directory of (env.PATH ?? "").split(delimiter)) {
-    if (!directory)
-      continue;
+  for (const directory of augmentedSearchDirectories(env)) {
     const candidate = resolve(directory, name);
     try {
       accessSync(candidate, constants.X_OK);
@@ -2389,7 +2451,7 @@ function requireExecutable(command, env, cwd, missingMessage) {
     } catch {
     }
   }
-  throw new Error(missingMessage);
+  throw new Error(`${missingMessage} Searched: ${describeExecutableSearch(env)}.`);
 }
 function parseAgentCommand(value) {
   const words = [];
@@ -3644,7 +3706,7 @@ var AcpClient = class extends EventEmitter {
     const current = this.activeRunIds.get(sessionId);
     if (current)
       return Promise.resolve(current);
-    return new Promise((resolve21, reject) => {
+    return new Promise((resolve22, reject) => {
       const onUpdate = (update) => {
         if (update.sessionId !== sessionId)
           return;
@@ -3652,7 +3714,7 @@ var AcpClient = class extends EventEmitter {
         if (!runId)
           return;
         cleanup();
-        resolve21(runId);
+        resolve22(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -3736,13 +3798,13 @@ var AcpClient = class extends EventEmitter {
     }
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve21, reject) => {
+    return new Promise((resolve22, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart)));
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: resolve21,
+        resolve: resolve22,
         reject,
         timer,
         method,
@@ -4075,7 +4137,13 @@ async function withAgentModelCatalog(agent, agentEnv, selection, inspect) {
     agentCommand: agent.command,
     agentArgs: agentArgsWithModelSelection(agent, selection),
     agentEnv,
-    agentCwd: scratchCwd
+    agentCwd: scratchCwd,
+    // The wizard probe runs on the human's own machine for a few seconds —
+    // inherit the caller's environment so harness launchers resolve (`pi`,
+    // `pi-acp`, `claude-agent-acp`'s `env node`) and fnm/homebrew toolchains
+    // work. Daemon sessions keep the allowlisted-env boundary; only this
+    // probe opts in.
+    inheritProcessEnv: true
   });
   try {
     await client.start();
@@ -4153,14 +4221,14 @@ import { promisify as promisify3 } from "node:util";
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile2 } from "node:child_process";
 import { mkdir as mkdir3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { promisify as promisify2 } from "node:util";
 
 // apps/body/dist/agent-home.js
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { chmod, copyFile, lstat, mkdir, readdir, realpath, rename, rm as rm2, symlink, unlink, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 import { basename as basename3, dirname as dirname2, relative, resolve as resolve6, sep } from "node:path";
 
 // apps/body/dist/beeline-skill.js
@@ -4172,18 +4240,31 @@ var BEELINE_ROOM_CAPABILITIES = [
   "You may address any Room member, including another agent, by writing @name in your reply; the server routes that mention to them.",
   "Tag another agent only when you need something from them: a question, a handoff, a task. Never tag to acknowledge, agree, or say you are ready. If nothing is actionable, do not reply.",
   "Tag the user only when you need a decision or input, or when the task they asked for is finished. Never tag for progress, acknowledgement, or questions the transcript already answers.",
-  "The beeline-readonly-mcp inspection tools and beeline-agent Room action tools are mounted. You can use beeline-readonly-mcp to search and read the bound repository without opening a corner; beeline-agent provides the host-governed Room actions.",
+  "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
   "To send a file, call beeline-agent attach_file with a path inside your checkout; it is attached to your reply.",
+  "To run something later or repeatedly, call beeline-agent create_schedule (interval in minutes or a 5-field cron, optional maxRuns); list_schedules / delete_schedule manage them.",
   "When repository work is needed, you MUST call beeline-agent open_corner with a one-paragraph summary of the complete objective. The host-governed call is the only way to start write work.",
   "Never claim an action or reply happened unless the prompt or a tool result proves it."
 ].join(" ");
-function beelinePrimer(repository) {
+var BEELINE_DM_CAPABILITIES = [
+  "This is a private direct-message conversation with one person. Every message they send is addressed to you; reply without tagging.",
+  "This Room is strictly conversational: there is no repository binding and no corner can be opened from here.",
+  "The repository filesystem is read-only in this session.",
+  "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
+  "To send a file, call beeline-agent attach_file with a path inside your checkout; it is attached to your reply.",
+  "Tag the person only when you need a decision or input, or when the task they asked for is finished.",
+  "Never claim an action or reply happened unless the prompt or a tool result proves it."
+].join(" ");
+function beelinePrimer(repository, directMessage) {
+  if (directMessage) {
+    return `Consult the release-versioned using-beeline skill (SKILL.md) when you need the managed Room mechanics. ${BEELINE_DM_CAPABILITIES}`;
+  }
   const repositoryLine = repository ? ` This Room is bound to ${repository.name} (branch ${repository.branch}); you have a read-only checkout at the session root.` : "";
   return `Consult the release-versioned using-beeline skill (SKILL.md) when you need the managed Room mechanics. ${BEELINE_ROOM_CAPABILITIES}${repositoryLine}`;
 }
 var BEELINE_CAPABILITIES_PRIMER = beelinePrimer();
-function beelineCapabilityContextForHarness(agentCommand, repository) {
-  const primer = beelinePrimer(repository);
+function beelineCapabilityContextForHarness(agentCommand, repository, directMessage) {
+  const primer = beelinePrimer(repository, directMessage);
   return {
     sessionPrompt: primer,
     ...harnessHonorsSessionSystemPrompt(agentCommand) ? {} : { compatibilityTurnPrefix: primer }
@@ -4210,7 +4291,7 @@ description: How to answer inside a Beeline Room.
 
 # Using Beeline
 
-You are answering inside a read-only Room. ${BEELINE_ROOM_CAPABILITIES}
+You are answering inside a Room whose filesystem is read-only. ${BEELINE_ROOM_CAPABILITIES}
 `;
 }
 
@@ -4391,7 +4472,12 @@ var SHARED_CREDENTIALS = [
 var BEELINE_DEFAULT_SKILL_NAMES = [
   USING_BEELINE_SKILL_NAME
 ];
-var EXPLICIT_SKILL_SOURCE_DIRS = [".agents/skills"];
+var OPERATOR_SKILL_SOURCE_DIRS = [
+  ".agents/skills",
+  ".claude/skills",
+  ".codex/skills",
+  ".pi/agent/skills"
+];
 var AGENT_SKILL_DIRS = ["claude", "codex", "grok", "pi"];
 var SHARED_SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function isSharedSkillName(value) {
@@ -4409,10 +4495,11 @@ var PI_CUSTOM_MODEL_CONFIG = {
   target: "models.json"
 };
 var CODEX_ROOM_AGENT_LOCKDOWN_TOML = "[agents]\nenabled = false\n";
+var CODEX_ROOM_WEB_SEARCH_TOML = "[features]\nstandalone_web_search = true\n";
 var HOME_SUBDIRS = ["user", "claude", "codex", "grok", "pi", "state", "cache", "tmp"];
 async function prepareRoomAgentHome(input) {
   const root = resolve6(input.root);
-  const operatorHome = input.operatorHome ?? homedir();
+  const operatorHome = input.operatorHome ?? homedir2();
   try {
     await mkdir(root, { recursive: true, mode: 448 });
     const rootStats = await lstat(root);
@@ -4452,17 +4539,17 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
   const managedSkills = [
     { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) }
   ];
-  const shared = await resolveExplicitSkillSources(operatorHome, sharedSkills);
+  const shared = await resolveSharedSkillSources(operatorHome, sharedSkills);
   for (const dir of AGENT_SKILL_DIRS) {
     const target = resolve6(root, dir, "skills");
-    await provisionManagedSkillsDir(target, managedSkills, shared);
+    await provisionManagedSkillsDir(target, managedSkills, shared, sharedSkills.length === 0);
   }
   for (const config of HARNESS_MCP_CONFIGS) {
     try {
       const source = resolve6(operatorHome, config.toml);
       const target = resolve6(root, config.dir, "config.toml");
       const mcpSection = existsSync3(source) ? filteredHarnessMcpToml(readFileSync4(source, "utf8")) : void 0;
-      const section = config.dir === "codex" ? [CODEX_ROOM_AGENT_LOCKDOWN_TOML, mcpSection].filter(Boolean).join("\n") : mcpSection;
+      const section = config.dir === "codex" ? [CODEX_ROOM_AGENT_LOCKDOWN_TOML, CODEX_ROOM_WEB_SEARCH_TOML, mcpSection].filter(Boolean).join("\n") : mcpSection;
       if (!section) {
         await unlink(target).catch(() => void 0);
         continue;
@@ -4489,6 +4576,15 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
       throw error;
     console.warn("[body] operator MCP passthrough failed for claude:", error);
   }
+  try {
+    const settings2 = { permissions: { allow: ["WebSearch"] } };
+    await writeIsolatedHarnessFile(resolve6(root, "claude", "settings.json"), `${JSON.stringify(settings2, null, 2)}
+`);
+  } catch (error) {
+    if (failClosed)
+      throw error;
+    console.warn("[body] claude web-search settings provisioning failed:", error);
+  }
   await provisionPiCustomModelConfig(root, operatorHome, failClosed);
 }
 async function provisionPiCustomModelConfig(root, operatorHome, failClosed) {
@@ -4540,7 +4636,7 @@ function filteredHarnessMcpToml(source) {
   });
   return extractTomlSections(source, ["mcp_servers"], excluded);
 }
-async function provisionManagedSkillsDir(target, managedSkills, sharedSkills) {
+async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, optionalShares) {
   const parent = dirname2(target);
   await assertRealContainedDirectory(parent, dirname2(parent));
   const staged = resolve6(parent, `.skills.${process.pid}.${randomUUID()}.tmp`);
@@ -4557,7 +4653,13 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills) {
         throw new Error(`shared skill collides with Beeline-owned skill: ${shared.name}`);
       }
       names.add(shared.name);
-      await copySafeSkillTree(shared.source, resolve6(staged, shared.name), shared.source);
+      try {
+        await copySafeSkillTree(shared.source, resolve6(staged, shared.name), shared.source);
+      } catch (error) {
+        if (!optionalShares)
+          throw error;
+        console.warn(`[body] skipping shared skill ${shared.name}:`, error);
+      }
     }
     const existing = await lstat(target).catch(() => void 0);
     if (existing)
@@ -4567,6 +4669,39 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills) {
     await rm2(staged, { recursive: true, force: true });
   }
 }
+async function resolveSharedSkillSources(operatorHome, names) {
+  if (names.length > 0)
+    return resolveExplicitSkillSources(operatorHome, names);
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const relativeRoot of OPERATOR_SKILL_SOURCE_DIRS) {
+    const sourceRoot = resolve6(operatorHome, relativeRoot);
+    const rootStats = await lstat(sourceRoot).catch(() => void 0);
+    if (!rootStats?.isDirectory() || rootStats.isSymbolicLink())
+      continue;
+    for (const entry of await readdir(sourceRoot)) {
+      if (!isSharedSkillName(entry) || seen.has(entry))
+        continue;
+      const candidate = resolve6(sourceRoot, entry);
+      try {
+        const candidateStats = await lstat(candidate);
+        if (!candidateStats.isDirectory() || candidateStats.isSymbolicLink())
+          continue;
+        assertContained(sourceRoot, candidate);
+        const skillMd = resolve6(candidate, "SKILL.md");
+        const skillStats = await lstat(skillMd);
+        if (!skillStats.isFile() || skillStats.isSymbolicLink() || skillStats.nlink !== 1) {
+          throw new Error(`shared skill requires an ordinary SKILL.md: ${entry}`);
+        }
+        seen.add(entry);
+        resolved.push({ name: entry, source: candidate });
+      } catch (error) {
+        console.warn(`[body] skipping operator skill ${entry}:`, error);
+      }
+    }
+  }
+  return resolved;
+}
 async function resolveExplicitSkillSources(operatorHome, names) {
   const unique = [...new Set(names)];
   for (const name of unique) {
@@ -4576,7 +4711,7 @@ async function resolveExplicitSkillSources(operatorHome, names) {
   const resolved = [];
   for (const name of unique) {
     const matches = [];
-    for (const relativeRoot of EXPLICIT_SKILL_SOURCE_DIRS) {
+    for (const relativeRoot of OPERATOR_SKILL_SOURCE_DIRS) {
       const sourceRoot = resolve6(operatorHome, relativeRoot);
       const candidate = resolve6(sourceRoot, name);
       const rootStats = await lstat(sourceRoot).catch(() => void 0);
@@ -4828,7 +4963,34 @@ function isReadOnlyMcpPermissionRequest(request) {
   }
   return false;
 }
+function isMountedMcpToolPermissionRequest(request) {
+  const toolCall = request.toolCall;
+  const rawInput = toolCall?.rawInput;
+  if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+    const call = rawInput;
+    if (typeof call.server === "string" && typeof call.tool === "string")
+      return true;
+  }
+  if (shellPayload(toolCall))
+    return false;
+  const title = toolCall?.title?.trim() ?? "";
+  if (/^mcp__[^_].*__[^_]/.test(title))
+    return true;
+  if (/^mcp\.[^.]+\.[^.]/.test(title))
+    return true;
+  return isReadOnlyMcpPermissionRequest(request) || isBeelineAgentMcpPermissionRequest(request);
+}
 var AGENT_SURFACE_TOOL_NAMES = ["open_corner", "pr_checks_status", "attach_file"];
+var SQUIRE_TITLE_PREFIXES = ["mcp__squire__", "mcp.squire.", "squire.", "squire/"];
+function isSquireMcpPermissionRequest(request) {
+  const rawInput = request.toolCall?.rawInput;
+  if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
+    if (rawInput.server === "squire")
+      return true;
+  }
+  const title = request.toolCall?.title?.trim() ?? "";
+  return SQUIRE_TITLE_PREFIXES.some((prefix) => title.startsWith(prefix));
+}
 function isBeelineAgentMcpPermissionRequest(request) {
   const toolCall = request.toolCall;
   const title = toolCall?.title?.trim() ?? "";
@@ -4864,6 +5026,7 @@ function beelineAgentMcpServer(config, api, context) {
     args: [...config.readonlyMcpArgs ?? []],
     env: [
       { name: "BEELINE_MCP_SURFACE", value: "agent" },
+      ...context.directMessage ? [{ name: "BEELINE_AGENT_DM", value: "1" }] : [],
       { name: "BEELINE_DAEMON_BASE_URL", value: connection.baseUrl },
       { name: "BEELINE_DAEMON_TOKEN", value: connection.daemonToken },
       { name: "BEELINE_DAEMON_AGENT_ID", value: connection.agentId },
@@ -4899,7 +5062,7 @@ function readOnlyMcpServer(config, cwd, agentMemoryDir) {
 // apps/body/dist/bwrap-sandbox.js
 import { spawnSync } from "node:child_process";
 import { lstatSync as lstatSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve8 } from "node:path";
 var DEFAULT_SANDBOX_POLICY = "bwrap";
 function isSandboxPolicy(value) {
@@ -4932,7 +5095,7 @@ var HARNESS_HOME_STATE_DIRS = [
     dirs: [".grok"]
   }
 ];
-function harnessHomeStateDirs(agentCommand, home = homedir2()) {
+function harnessHomeStateDirs(agentCommand, home = homedir3()) {
   if (!agentCommand)
     return [];
   for (const { match, dirs } of HARNESS_HOME_STATE_DIRS) {
@@ -4949,7 +5112,7 @@ var KNOWN_CREDENTIAL_MASK_PATHS = [
   ".git-credentials",
   ".secrets.env"
 ];
-function credentialMaskPaths(extraPaths, home = homedir2(), stat3 = (path) => {
+function credentialMaskPaths(extraPaths, home = homedir3(), stat3 = (path) => {
   try {
     const info = lstatSync2(path);
     return { isDirectory: info.isDirectory() };
@@ -5149,7 +5312,7 @@ import { randomBytes as randomBytes5 } from "node:crypto";
 import { execFile } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { mkdir as mkdir2, readFile, readdir as readdir2, rename as rename2, stat, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { dirname as dirname3, resolve as resolve9 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { promisify } from "node:util";
@@ -9538,7 +9701,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join(separator = "") {
+function join2(separator = "") {
   astr("join", separator);
   return {
     encode: (from) => {
@@ -9668,8 +9831,8 @@ var base64 = hasBase64Builtin ? {
   decode(s) {
     return decodeBase64Builtin(s, false);
   }
-} : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join(""));
-var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
+} : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join2(""));
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join2(""));
 var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
 function bech32Polymod(pre) {
   const b = pre >> 25;
@@ -13687,7 +13850,7 @@ var DEFAULT_AGENT_IDENTITY_NAME = "beeline-agent";
 var DEFAULT_BODY_IDENTITY_NAME = "beeline-body";
 var DEFAULT_DAEMON_MONOLITH_BASE_URL = "https://server.usebeeline.app";
 function defaultSupervisorRoot(env = process.env) {
-  return resolve9(env.XDG_STATE_HOME ?? resolve9(homedir3(), ".local", "state"));
+  return resolve9(env.XDG_STATE_HOME ?? resolve9(homedir4(), ".local", "state"));
 }
 function runtimeDirectory(supervisorRoot, publicKey) {
   if (!/^[0-9a-f]{64}$/i.test(publicKey))
@@ -13896,6 +14059,9 @@ async function removeAgentRuntime(runtime) {
   return target;
 }
 
+// apps/body/dist/response-directives.js
+var MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE = "Maintain your assigned identity and soul in every response, including when tools or permissions block the requested action.";
+
 // apps/body/dist/monolith-corner-turn.js
 var execFileAsync2 = promisify2(execFile2);
 var PULL_REQUEST_URL = /https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+/;
@@ -14035,6 +14201,7 @@ var MonolithCornerTurnLoop = class {
   agent;
   client;
   sessionId;
+  turnIdentityInstructions = "";
   busy = false;
   forcedStop = false;
   draftTail = Promise.resolve();
@@ -14095,7 +14262,7 @@ var MonolithCornerTurnLoop = class {
       command,
       args: this.options.config.agentArgs ?? []
     }, selection);
-    const operatorHome = this.options.config.operatorHome ?? homedir4();
+    const operatorHome = this.options.config.operatorHome ?? homedir5();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
     await Promise.all(homeStateDirs.map((dir) => mkdir3(dir, { recursive: true })));
@@ -14148,14 +14315,17 @@ var MonolithCornerTurnLoop = class {
       })
     ];
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
-    const persona = self?.soul;
+    const persona = configuration.soul ?? self?.soul;
+    const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
+    const personaInstructions = persona?.instructions ? `Human-authored Workspace persona: ${persona.name}. ${persona.instructions}` : "";
+    this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
       cwd: this.options.worktreePath,
       mcpServers: servers,
       mode: "edit",
       systemPrompt: [
-        `Your Beeline identity is ${self?.name ?? this.agent.name}.`,
-        persona?.instructions ? `Human-authored Workspace persona: ${persona.name}. ${persona.instructions}` : "",
+        identityInstructions,
+        personaInstructions,
         `You are in an isolated git worktree on ${this.options.featureBranch}, targeting ${this.options.targetBranch}.`,
         "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
         "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
@@ -14206,17 +14376,49 @@ var MonolithCornerTurnLoop = class {
         const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
         const transcript = conversation.items.slice(-120).map((message) => `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`).join("\n");
         const prompt = [
+          this.turnIdentityInstructions,
           `Corner objective:
 ${this.options.objective}`,
           transcript ? `Corner transcript:
 ${transcript}` : "",
           `Newest trigger:
 ${trigger}`,
-          "Continue the objective. Obey the PR checks and human hold rules in your session instructions."
+          "Continue the objective. Obey the PR checks and human hold rules in your session instructions.",
+          MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
         ].filter(Boolean).join("\n\n");
         const sessionId = this.sessionId;
         const turnId = requestId;
         const publishedToolCalls = /* @__PURE__ */ new Set();
+        const NARRATION_MAX_SEGMENTS = 20;
+        let narrationPostedChars = 0;
+        let narrationSegments = 0;
+        const postNarrationSegments = (full) => {
+          if (narrationSegments >= NARRATION_MAX_SEGMENTS)
+            return;
+          const unposted = full.slice(narrationPostedChars);
+          const boundaries = [...unposted.matchAll(/\n\n|[.!?](?=\s)/g)];
+          if (!boundaries.length)
+            return;
+          const boundary = boundaries[boundaries.length - 1];
+          const segmentEnd = narrationPostedChars + boundary.index + boundary[0].length;
+          const segment = stripAgentReplyPreamble(full.slice(narrationPostedChars, segmentEnd));
+          const start = narrationPostedChars;
+          narrationPostedChars = segmentEnd;
+          narrationSegments += 1;
+          const trimmed = segment.trim();
+          if (!trimmed)
+            return;
+          this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
+            await api.execute("postRoomMessage", {
+              roomId: cornerId,
+              text: trimmed,
+              presentation: "message"
+            });
+          }).catch(() => {
+            narrationPostedChars = start;
+            narrationSegments -= 1;
+          });
+        };
         const publishToolCalls = (calls, settledOnly) => {
           calls.forEach((call, index) => {
             const key = toolCallKey(call, index);
@@ -14238,6 +14440,7 @@ ${trigger}`,
           });
         };
         const result = await this.client.sessionPrompt(sessionId, prompt, 12e4, (_delta, full) => {
+          postNarrationSegments(full);
           this.draftTail = this.draftTail.catch(() => void 0).then(() => api.execute("postAgentDraft", {
             agentId: this.agent.publicKey,
             roomId: cornerId,
@@ -14249,15 +14452,19 @@ ${trigger}`,
         publishToolCalls(result.toolCalls, false);
         await this.activityTail;
         await this.draftTail;
+        await this.activityTail;
         const reply = stripAgentReplyPreamble(result.agentText).trim();
         if (!reply)
           throw new Error("ACP corner turn produced no durable reply");
-        await api.execute("postRoomMessage", {
-          roomId: cornerId,
-          requestId,
-          text: reply,
-          presentation: "message"
-        });
+        const durableTail = narrationPostedChars > 0 ? stripAgentReplyPreamble(result.agentText.slice(narrationPostedChars)).trim() : reply;
+        if (durableTail) {
+          await api.execute("postRoomMessage", {
+            roomId: cornerId,
+            requestId,
+            text: durableTail,
+            presentation: "message"
+          });
+        }
         const pullRequest = reply.match(PULL_REQUEST_URL)?.[0];
         const alreadyReady = conversation.items.some((item) => /\bPR ready for review\b/i.test(item.body));
         if (pullRequest && !alreadyReady) {
@@ -14368,9 +14575,11 @@ async function wait(ms, signal) {
 
 // apps/body/dist/monolith-room-turn.js
 import { mkdir as mkdir4 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 function isRoomMcpPermissionRequest(request) {
-  return isReadOnlyMcpPermissionRequest(request) || isBeelineAgentMcpPermissionRequest(request);
+  if (isSquireMcpPermissionRequest(request))
+    return false;
+  return isMountedMcpToolPermissionRequest(request);
 }
 function roomPrincipalMayAddressAgent(authority, humanPermitted) {
   return authority.member && (authority.principalKind === "agent" || authority.principalKind === "human" && humanPermitted);
@@ -14453,6 +14662,7 @@ var MonolithRoomTurnLoop = class {
       this.roster(),
       this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId })
     ]);
+    const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
     await mkdir4(this.options.cwd, { recursive: true });
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
@@ -14467,7 +14677,7 @@ var MonolithRoomTurnLoop = class {
       command,
       args: this.options.config.agentArgs ?? []
     }, selection);
-    const operatorHome = this.options.config.operatorHome ?? homedir5();
+    const operatorHome = this.options.config.operatorHome ?? homedir6();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
     await Promise.all(homeStateDirs.map((dir) => mkdir4(dir, { recursive: true })));
@@ -14500,7 +14710,8 @@ var MonolithRoomTurnLoop = class {
       beelineAgentMcpServer(this.options.config, this.options.api, {
         roomId: this.options.roomId,
         workspaceId: this.options.workspaceId,
-        attachRoot: this.options.cwd
+        attachRoot: this.options.cwd,
+        directMessage
       })
     ];
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
@@ -14516,7 +14727,7 @@ var MonolithRoomTurnLoop = class {
       name: repositoryState.key,
       branch: repositoryState.targetBranch || "main"
     } : void 0;
-    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo);
+    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo, directMessage);
     this.turnInstructionPrefix = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions, capabilityContext.compatibilityTurnPrefix].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
       cwd: this.options.cwd,
@@ -14617,7 +14828,8 @@ ${transcript}` : "",
           [
             "Write only the substantive Room message you want the human to read.",
             "Do not repeat or paraphrase these instructions.",
-            "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge."
+            "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
+            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].join(" ")
         ].filter(Boolean).join("\n\n");
         const sessionId = this.sessionId;
@@ -15842,7 +16054,7 @@ var import_picocolors = __toESM(require_picocolors(), 1);
 // apps/body/dist/systemd.js
 import { execFile as execFile4 } from "node:child_process";
 import { mkdir as mkdir6, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { dirname as dirname5, resolve as resolve12 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify4 } from "node:util";
@@ -15884,7 +16096,7 @@ WantedBy=default.target
 `;
 }
 function isCanonicalInstalledLauncher(env = process.env, invocationPath = process.argv[1]) {
-  const home = env.HOME?.trim() || homedir6();
+  const home = env.HOME?.trim() || homedir7();
   const expectedLibDir = resolve12(home, ".local", "lib", "beeline");
   const expectedPrefix = `${expectedLibDir}/`;
   return resolve12(env.BEELINE_LIB_DIR?.trim() || "/") === expectedLibDir && Boolean(invocationPath) && resolve12(invocationPath).startsWith(expectedPrefix);
@@ -15895,7 +16107,7 @@ function assertCanonicalInstalledLauncher(env, invocationPath) {
   throw new Error("refusing to modify the shared Beeline systemd unit outside the canonical ~/.local/bin/beeline launcher");
 }
 function systemdUserUnitPath(env = process.env) {
-  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve12(homedir6(), ".config");
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve12(homedir7(), ".config");
   return resolve12(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 var runSystemctl = async (args) => {
@@ -16069,8 +16281,9 @@ async function runStartCommand(args, interactiveUi) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
-import { chmod as chmod3, mkdir as mkdir8, readFile as readFile4, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname8, resolve as resolve14 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { chmod as chmod4, mkdir as mkdir9, readFile as readFile5, unlink as unlink2, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname9, resolve as resolve15 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
 // packages/api-contract/dist/agent-pairing-code.js
@@ -16107,6 +16320,65 @@ function unwrapPrompt(value, cancelMessage = "Cancelled.") {
   return value;
 }
 
+// apps/body/dist/provider-key-check.js
+var PROVIDER_LABELS = {
+  openrouter: "OpenRouter",
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  google: "Google",
+  xai: "xAI"
+};
+function keyCheckEndpoint(provider, apiKey) {
+  switch (provider) {
+    case "openrouter":
+      return {
+        url: "https://openrouter.ai/api/v1/key",
+        headers: { authorization: `Bearer ${apiKey}` }
+      };
+    case "openai":
+      return {
+        url: "https://api.openai.com/v1/models?limit=1",
+        headers: { authorization: `Bearer ${apiKey}` }
+      };
+    case "anthropic":
+      return {
+        url: "https://api.anthropic.com/v1/models?limit=1",
+        headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+      };
+    case "google":
+      return {
+        url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
+        headers: { "x-goog-api-key": apiKey }
+      };
+    case "xai":
+      return {
+        url: "https://api.x.ai/v1/models?limit=1",
+        headers: { authorization: `Bearer ${apiKey}` }
+      };
+  }
+}
+var REJECTED_STATUS = /* @__PURE__ */ new Set([400, 401, 403]);
+async function verifyProviderKey(input) {
+  const label = PROVIDER_LABELS[input.provider];
+  const { url, headers } = keyCheckEndpoint(input.provider, input.apiKey);
+  let response;
+  try {
+    response = await (input.fetchImpl ?? fetch)(url, {
+      headers,
+      signal: AbortSignal.timeout(input.timeoutMs ?? 15e3)
+    });
+  } catch (error) {
+    const cause = error instanceof Error ? error.message.split("\n")[0] : String(error);
+    throw new Error(`Could not reach ${label} to verify the key (${cause}). Check the network and paste the key again.`);
+  }
+  if (response.ok)
+    return;
+  if (REJECTED_STATUS.has(response.status)) {
+    throw new Error(`${label} rejected the key (${response.status}).`);
+  }
+  throw new Error(`${label} could not verify the key right now (HTTP ${response.status}). Try again in a moment.`);
+}
+
 // apps/body/dist/pair-agent-selection.js
 import { spawn as spawn3 } from "node:child_process";
 import { stdin as stdin2, stdout as stdout3 } from "node:process";
@@ -16305,6 +16577,63 @@ async function completeDevicePairing(grant, options = {}) {
   return { runtime: activated.runtime, configPath: staged.configPath, pid };
 }
 
+// apps/body/dist/provider-key-store.js
+import { chmod as chmod2, mkdir as mkdir7, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname7, resolve as resolve13 } from "node:path";
+var PROVIDER_KEY_ENV_VARS = {
+  openrouter: "OPENROUTER_API_KEY",
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GOOGLE_API_KEY",
+  xai: "XAI_API_KEY"
+};
+var GOOGLE_ENV_ALIAS = "GEMINI_API_KEY";
+function providerKeyStorePath(env = process.env) {
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve13(homedir8(), ".config");
+  return resolve13(configRoot, "beeline", "providers.json");
+}
+async function readProviderKeyStore(env = process.env) {
+  const path = providerKeyStorePath(env);
+  const raw = await readFile3(path, "utf8").catch(() => void 0);
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    const entries = Object.entries(parsed).filter((entry) => entry[0] in PROVIDER_KEY_ENV_VARS && typeof entry[1] === "string" && entry[1].length > 0);
+    return Object.fromEntries(entries);
+  } catch {
+    return {};
+  }
+}
+async function readSavedProviderKey(provider, env = process.env) {
+  return (await readProviderKeyStore(env))[provider];
+}
+async function saveProviderKey(provider, key, env = process.env) {
+  const path = providerKeyStorePath(env);
+  const store = { ...await readProviderKeyStore(env), [provider]: key };
+  await mkdir7(dirname7(path), { recursive: true, mode: 448 });
+  await writeFile4(path, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+  await chmod2(path, 384);
+}
+function providerKeyFromEnvironment(provider, env = process.env) {
+  const primary = env[PROVIDER_KEY_ENV_VARS[provider]]?.trim();
+  if (primary)
+    return primary;
+  if (provider === "google")
+    return env[GOOGLE_ENV_ALIAS]?.trim() || void 0;
+  return void 0;
+}
+function maskProviderKey(key) {
+  const trimmed = key.trim();
+  if (trimmed.length <= 9)
+    return "\u2026";
+  return `${trimmed.slice(0, 6)}\u2026${trimmed.slice(-3)}`;
+}
+
 // apps/body/dist/connect-command.js
 init_self_update();
 init_self_update_manifest();
@@ -16315,7 +16644,17 @@ function isReasonableAgentName(value) {
   return normalized.length > 0 && normalized.length <= AGENT_NAME_MAX_LENGTH && new RegExp("^\\p{L}[\\p{L}\\p{M}'\u2019 -]*$", "u").test(normalized);
 }
 var CONNECT_PROVIDER_HARNESSES = /* @__PURE__ */ new Set(["goose", "pi"]);
-var CONNECT_PROVIDERS = ["openrouter", "openai", "anthropic", "google", "xai"];
+var CONNECT_PROVIDERS = [
+  "openrouter",
+  "openai",
+  "anthropic",
+  "google",
+  "xai"
+];
+var fileConnectKeyStore = {
+  read: (provider) => readSavedProviderKey(provider),
+  save: (provider, key) => saveProviderKey(provider, key)
+};
 var DEFAULT_MODELS = {
   openrouter: "z-ai/glm-5.3-flash",
   openai: "gpt-5.4",
@@ -16373,6 +16712,21 @@ var clackPrompts = {
     }), "Connection cancelled.");
   }
 };
+function connectModelPickerFromAxes(axes, fallbackModel, harness) {
+  const filtered = axes.find((axis) => axis.category === "model");
+  if (filtered?.options.length) {
+    return { currentValue: filtered.currentValue, options: filtered.options };
+  }
+  const raw = axes.find((axis) => axis.category === "model" && axis.options.length);
+  if (raw) {
+    return { currentValue: raw.currentValue, options: raw.options };
+  }
+  return {
+    currentValue: fallbackModel,
+    options: [{ id: fallbackModel }],
+    note: `${harness} did not enumerate models; offering the provider default`
+  };
+}
 async function loadConnectModelCatalog(input) {
   const agent = resolveAgentCommand({ kind: input.harness });
   const catalog = await fetchAgentModelCatalog(agent, providerEnvironment({
@@ -16381,13 +16735,9 @@ async function loadConnectModelCatalog(input) {
     ...input.apiKey ? { apiKey: input.apiKey } : {},
     model: defaultConnectModel(input.harness, input.provider)
   }));
-  const modelAxis = catalog.catalog.find((axis) => axis.category === "model");
-  if (!modelAxis?.options.length) {
-    throw new Error(`${input.harness} did not advertise any available models`);
-  }
-  return { currentValue: modelAxis.currentValue, options: modelAxis.options };
+  return connectModelPickerFromAxes(catalog.catalog, defaultConnectModel(input.harness, input.provider), input.harness);
 }
-async function collectConnectWizard(prompts = clackPrompts, loadModels = loadConnectModelCatalog) {
+async function collectConnectWizard(prompts = clackPrompts, loadModels = loadConnectModelCatalog, keyStore = fileConnectKeyStore, env = process.env, verifyKey = (input) => verifyProviderKey(input)) {
   const harness = await prompts.select({
     message: brass("Choose harness"),
     options: CONNECT_HARNESSES.map((value) => ({
@@ -16407,10 +16757,44 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
         ...value === "openrouter" ? { hint: "default" } : {}
       }))
     });
-    apiKey = await prompts.password({
-      message: brass(`${provider === "openrouter" ? "OpenRouter" : provider} API key`),
-      validate: (value) => value.trim() ? void 0 : "API key is required"
-    });
+    const providerLabel = provider === "openrouter" ? "OpenRouter" : provider;
+    const savedKey = await keyStore.read(provider);
+    const envKey = providerKeyFromEnvironment(provider, env);
+    const availableKey = savedKey ?? envKey;
+    if (availableKey) {
+      const masked = maskProviderKey(availableKey);
+      const choice = await prompts.select({
+        message: brass(`${providerLabel} API key`),
+        initialValue: "saved",
+        options: [
+          {
+            value: "saved",
+            label: savedKey ? `Use saved ${providerLabel} key (${masked})` : `Use ${PROVIDER_KEY_ENV_VARS[provider]} from the environment (${masked})`
+          },
+          { value: "new", label: "Enter a new key" }
+        ]
+      });
+      if (choice === "saved") {
+        apiKey = availableKey;
+        await verifyKey({ provider, apiKey });
+      } else {
+        apiKey = await prompts.password({
+          message: brass(`${providerLabel} API key`),
+          validate: (value) => value.trim() ? void 0 : "API key is required"
+        });
+        apiKey = apiKey.trim();
+        await verifyKey({ provider, apiKey });
+        await keyStore.save(provider, apiKey);
+      }
+    } else {
+      apiKey = await prompts.password({
+        message: brass(`${providerLabel} API key`),
+        validate: (value) => value.trim() ? void 0 : "API key is required"
+      });
+      apiKey = apiKey.trim();
+      await verifyKey({ provider, apiKey });
+      await keyStore.save(provider, apiKey);
+    }
   }
   const catalog = await loadModels({
     harness,
@@ -16419,7 +16803,7 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
   });
   const initialModel = catalog.currentValue ?? defaultConnectModel(harness, provider);
   const model = await prompts.autocomplete({
-    message: brass("Choose model"),
+    message: brass(catalog.note ? `Choose model (${catalog.note})` : "Choose model"),
     options: catalog.options.map((choice) => ({
       value: choice.id,
       label: choice.name ? `${choice.name} (${choice.id})` : choice.id
@@ -16466,12 +16850,14 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
+  const avatarSeed = createHash3("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
   return jsonRequest(`${baseUrl}/auth/agent/connect`, {
     pairing_code: normalizedPairingCode,
     harness: selection.harness,
     ...selection.provider ? { provider: selection.provider } : {},
     model: selection.model,
     soul: selection.soul,
+    avatar_seed: avatarSeed,
     agent_name: selection.name
   }, fetchImpl);
 }
@@ -16489,7 +16875,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve14(layout.binDir, "beeline"),
+    binary: resolve15(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -16512,21 +16898,21 @@ function providerEnvironment(selection) {
   };
 }
 async function writePrivateJson(path, value) {
-  await mkdir8(dirname8(path), { recursive: true, mode: 448 });
-  await writeFile5(path, `${JSON.stringify(value, null, 2)}
+  await mkdir9(dirname9(path), { recursive: true, mode: 448 });
+  await writeFile6(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  await chmod3(path, 384);
+  await chmod4(path, 384);
 }
 async function writeProviderEnv(selection, agentPubkey) {
   const values = providerEnvironment(selection);
   if (Object.keys(values).length === 0)
     return void 0;
-  const path = resolve14(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
-  await mkdir8(dirname8(path), { recursive: true, mode: 448 });
+  const path = resolve15(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
+  await mkdir9(dirname9(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
-  await writeFile5(path, `${contents}
+  await writeFile6(path, `${contents}
 `, { mode: 384 });
-  await chmod3(path, 384);
+  await chmod4(path, 384);
   return path;
 }
 async function runInstalledFinish(binary, grantPath) {
@@ -16568,17 +16954,17 @@ async function runConnectCommand(code, options = {}) {
     throw new Error("`usebeeline connect` needs an interactive terminal");
   }
   intro(brass("Beeline connect"));
+  const fetchImpl = options.fetchImpl ?? fetch;
   const pairingCode = code?.trim() || await clackPrompts.text({
     message: brass("Pairing code from the app"),
     validate: (value) => normalizeAgentPairingCode(value) ? void 0 : "Enter the pairing code shown in the app"
   });
-  const selection = await collectConnectWizard();
-  const fetchImpl = options.fetchImpl ?? fetch;
+  const selection = await collectConnectWizard(clackPrompts, loadConnectModelCatalog, fileConnectKeyStore, process.env, (input) => verifyProviderKey({ ...input, fetchImpl }));
   const baseUrl = (process.env.BEELINE_AUTH_URL ?? "https://server.usebeeline.app").replace(/\/$/, "");
   const grant = await brassSpinner("Connecting to your Beeline Workspace\u2026", () => requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl), (connectedGrant) => `Connected to ${connectedGrant.workspace_name}`);
   const installedRelease = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl), (release) => `Installed Beeline helper ${release.version}`);
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
-  const grantPath = resolve14(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
+  const grantPath = resolve15(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
@@ -16611,17 +16997,32 @@ function isDevicePairingGrant(value) {
   }
   return typeof grant.agentSecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.agentSecretKey) && typeof grant.bodySecretKey === "string" && /^[0-9a-f]{64}$/.test(grant.bodySecretKey) && typeof grant.agentName === "string" && CONNECT_HARNESSES.includes(grant.harness) && typeof grant.model === "string" && typeof grant.soul === "string" && typeof grant.workspaceId === "string" && typeof grant.workspaceName === "string" && typeof grant.pairedBy === "string" && /^[0-9a-f]{64}$/.test(grant.pairedBy) && typeof grant.monolithBaseUrl === "string" && grant.monolithBaseUrl === monolithOrigin && /^https?:$/.test(new URL(monolithOrigin).protocol) && typeof grant.daemonExchangeToken === "string" && /^bde_[A-Za-z0-9_-]{43}$/.test(grant.daemonExchangeToken);
 }
+function connectPlainFailure(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const firstLine = raw.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
+  return `Connecting your agent failed: ${firstLine ?? "unknown error"}`;
+}
+var ConnectFailureError = class extends Error {
+  constructor(sentence) {
+    super(sentence);
+    this.name = "ConnectFailureError";
+  }
+};
 async function runConnectFinishCommand(path) {
   if (!path)
     throw new Error("connect-finish requires a grant path");
   if (!isCanonicalInstalledLauncher(process.env, process.argv[1])) {
     throw new Error("connect-finish may run only from the canonical installed Beeline launcher");
   }
-  const grant = JSON.parse(await readFile4(resolve14(path), "utf8"));
-  if (!isDevicePairingGrant(grant))
-    throw new Error("device connection grant is invalid");
-  await completeDevicePairing(grant);
-  await unlink2(resolve14(path));
+  try {
+    const grant = JSON.parse(await readFile5(resolve15(path), "utf8"));
+    if (!isDevicePairingGrant(grant))
+      throw new Error("device connection grant is invalid");
+    await completeDevicePairing(grant);
+    await unlink2(resolve15(path));
+  } catch (error) {
+    throw new ConnectFailureError(connectPlainFailure(error));
+  }
 }
 
 // apps/body/dist/self-update-cli.js
@@ -16632,20 +17033,20 @@ init_self_update_manifest();
 // apps/body/dist/managed-update.js
 init_self_update();
 import { spawn as spawn6 } from "node:child_process";
-import { mkdir as mkdir10, rm as rm5, stat as stat2, writeFile as writeFile7 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve16 } from "node:path";
+import { mkdir as mkdir11, rm as rm5, stat as stat2, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve17 } from "node:path";
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir9, readFile as readFile5, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname9, resolve as resolve15 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile6, rename as rename4, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname10, resolve as resolve16 } from "node:path";
 function updateRollbackAlertPath(runtimeDir) {
-  return resolve15(runtimeDir, "update-rollback-alert.json");
+  return resolve16(runtimeDir, "update-rollback-alert.json");
 }
 async function writeAlert(runtimeDir, alert) {
   const path = updateRollbackAlertPath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir9(dirname9(path), { recursive: true });
-  await writeFile6(staged, `${JSON.stringify(alert, null, 2)}
+  await mkdir10(dirname10(path), { recursive: true });
+  await writeFile7(staged, `${JSON.stringify(alert, null, 2)}
 `, { mode: 384 });
   await rename4(staged, path);
 }
@@ -16657,7 +17058,7 @@ async function queueUpdateRollbackAlert(runtimeDir, releaseId, now2 = Date.now()
 }
 async function readUpdateRollbackAlert(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile5(updateRollbackAlertPath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile6(updateRollbackAlertPath(runtimeDir), "utf8"));
     if (value.version !== 1 || typeof value.releaseId !== "string")
       return void 0;
     return value;
@@ -16682,13 +17083,13 @@ var LOCK_STALE_MS = UPDATE_WORKER_DEADLINE_MS + 5 * 6e4;
 var DEFAULT_UPDATE_INITIAL_DELAY_MS = 0;
 async function withInstallLock(layout, work, options = {}) {
   const now2 = options.now ?? Date.now;
-  const lock = resolve16(layout.releasesRoot, ".state", "install.lock");
+  const lock = resolve17(layout.releasesRoot, ".state", "install.lock");
   const deadline = now2() + (options.waitMs ?? 1e4);
-  await mkdir10(dirname10(lock), { recursive: true });
+  await mkdir11(dirname11(lock), { recursive: true });
   for (; ; ) {
     try {
-      await mkdir10(lock);
-      await writeFile7(resolve16(lock, "owner"), `${process.pid}
+      await mkdir11(lock);
+      await writeFile8(resolve17(lock, "owner"), `${process.pid}
 ${now2()}
 `, "utf8");
       break;
@@ -16812,7 +17213,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       if (!attempt || attempt.releaseId !== desiredRelease || attempt.status !== "pending") {
         const from = await readInstalledBundleIdentity({
           ...this.#layout,
-          libDir: resolve16(this.#layout.releasesRoot, this.#loadedRelease)
+          libDir: resolve17(this.#layout.releasesRoot, this.#loadedRelease)
         }).catch(() => void 0) ?? {};
         const to = await readInstalledBundleIdentity(this.#layout).catch(() => void 0) ?? {};
         const record2 = {
@@ -17019,7 +17420,7 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
   });
   if (!accepted)
     return false;
-  await writeFile7(resolve16(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
+  await writeFile8(resolve17(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
     readyAt: (options.now ?? Date.now)(),
     loadedRelease,
     functionalProof: options.functionalProof
@@ -17224,16 +17625,16 @@ async function runUpdateCommand(args) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir11, readFile as readFile6, rename as rename5, rm as rm6, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve17 } from "node:path";
+import { mkdir as mkdir12, readFile as readFile7, rename as rename5, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname12, resolve as resolve18 } from "node:path";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
 function daemonFailurePath(runtimeDir) {
-  return resolve17(runtimeDir, "daemon-distress.json");
+  return resolve18(runtimeDir, "daemon-distress.json");
 }
 async function readFailureRecord(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile6(daemonFailurePath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile7(daemonFailurePath(runtimeDir), "utf8"));
     if (value.version !== 1 || !Array.isArray(value.failures) || value.failures.some((failure) => typeof failure !== "number") || typeof value.lastError !== "string") {
       return void 0;
     }
@@ -17245,8 +17646,8 @@ async function readFailureRecord(runtimeDir) {
 async function writeFailureRecord(runtimeDir, record2) {
   const path = daemonFailurePath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir11(dirname11(path), { recursive: true, mode: 448 });
-  await writeFile8(staged, `${JSON.stringify(record2, null, 2)}
+  await mkdir12(dirname12(path), { recursive: true, mode: 448 });
+  await writeFile9(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
   await rename5(staged, path);
 }
@@ -17268,9 +17669,9 @@ async function clearDaemonStartFailures(runtimeDir) {
 }
 
 // apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir12, rm as rm7 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { resolve as resolve18 } from "node:path";
+import { mkdir as mkdir13, rm as rm7 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import { resolve as resolve19 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
 var UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS = 2e4;
 var UPDATE_PROBE_TURN_TIMEOUT_MS = 45e3;
@@ -17292,18 +17693,18 @@ async function runUpdateFunctionalProbe(input) {
   if (input.sandboxRequired && !input.config.bwrapPath) {
     throw new UpdateFunctionalProbeError("sandbox-unavailable", "the configured bubblewrap boundary did not pass its startup self-test");
   }
-  const root = resolve18(input.runtimeDir, "update-functional-probe");
-  const cwd = resolve18(root, "checkout");
-  const homeRoot = resolve18(root, "agent-home");
+  const root = resolve19(input.runtimeDir, "update-functional-probe");
+  const cwd = resolve19(root, "checkout");
+  const homeRoot = resolve19(root, "agent-home");
   await rm7(root, { recursive: true, force: true });
-  await mkdir12(cwd, { recursive: true, mode: 448 });
+  await mkdir13(cwd, { recursive: true, mode: 448 });
   let client;
   try {
     const agentEnv = {
       ...input.config.agentEnv,
       ...await prepareRoomAgentHome({
         root: homeRoot,
-        operatorHome: input.config.operatorHome ?? homedir8(),
+        operatorHome: input.config.operatorHome ?? homedir10(),
         sharedSkills: input.config.sharedSkills ?? [],
         skillReleaseId: input.releaseId,
         failClosed: true
@@ -17320,9 +17721,9 @@ async function runUpdateFunctionalProbe(input) {
     };
     if (input.config.bwrapPath) {
       const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-      const operatorHome = input.config.operatorHome ?? homedir8();
+      const operatorHome = input.config.operatorHome ?? homedir10();
       const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-      await Promise.all(homeStateDirs.map((dir) => mkdir12(dir, { recursive: true })));
+      await Promise.all(homeStateDirs.map((dir) => mkdir13(dir, { recursive: true })));
       spawnCommand = wrapAgentCommand({
         bwrapPath: input.config.bwrapPath,
         spec: {
@@ -17386,8 +17787,8 @@ async function runUpdateFunctionalProbe(input) {
 }
 
 // apps/body/dist/release-status.js
-import { readFile as readFile7, readdir as readdir3, rename as rename6, writeFile as writeFile9 } from "node:fs/promises";
-import { resolve as resolve19 } from "node:path";
+import { readFile as readFile8, readdir as readdir3, rename as rename6, writeFile as writeFile10 } from "node:fs/promises";
+import { resolve as resolve20 } from "node:path";
 var DAEMON_RELEASE_STATUS_FILE = "release-status.json";
 var RELEASE_VERSION = /^v\d+\.\d+\.\d+$/;
 var SOURCE_SHA = /^[0-9a-f]{7,64}$/;
@@ -17404,9 +17805,9 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
     pid: options.pid ?? process.pid,
     readyAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
   };
-  const target = resolve19(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
+  const target = resolve20(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
   const temporary = `${target}.${status.pid}.tmp`;
-  await writeFile9(temporary, `${JSON.stringify(status, null, 2)}
+  await writeFile10(temporary, `${JSON.stringify(status, null, 2)}
 `, { mode: 384 });
   await rename6(temporary, target);
   return status;
@@ -17447,7 +17848,7 @@ var DaemonExitError = class extends Error {
 };
 async function runStoredDaemon(pathOrPointer) {
   const configPath = await resolveRuntimeConfigPath(pathOrPointer);
-  daemonFailureRuntimeDir = dirname12(configPath);
+  daemonFailureRuntimeDir = dirname13(configPath);
   const accessMigration = await migrateRuntimeRecordAccessPolicy(configPath);
   let runtime = accessMigration.runtime;
   if (!runtime.transport) {
@@ -17459,7 +17860,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile10(resolve20(dirname12(configPath), "daemon.pid"), `${process.pid}
+  await writeFile11(resolve21(dirname13(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -17467,7 +17868,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve20(dirname12(configPath), "workspace"),
+    workspaceRoot: resolve21(dirname13(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -17502,7 +17903,7 @@ async function runStoredDaemon(pathOrPointer) {
   const stop = () => controller.abort();
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
-  const runtimeDir = dirname12(configPath);
+  const runtimeDir = dirname13(configPath);
   const layout = beelineInstallLayout(process.env);
   const notifier = new SystemdNotifier();
   let rollbackAlertDrain;
@@ -17614,8 +18015,8 @@ async function runStoredDaemon(pathOrPointer) {
     throw error;
   } finally {
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve20(dirname12(configPath), "daemon.pid");
-    const recorded = Number((await readFile8(pidPath, "utf8").catch(() => "")).trim());
+    const pidPath = resolve21(dirname13(configPath), "daemon.pid");
+    const recorded = Number((await readFile9(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
       await unlink3(pidPath).catch(() => void 0);
     }
@@ -17671,14 +18072,14 @@ async function main() {
     const agentPubkey = agentFlag >= 0 ? args[agentFlag + 1] : void 0;
     if (!configPath && agentPubkey) {
       const configs = await findAgentRuntimeConfigPaths(process.env, process.cwd());
-      configPath = configs.find((candidate) => dirname12(candidate).endsWith(agentPubkey));
+      configPath = configs.find((candidate) => dirname13(candidate).endsWith(agentPubkey));
     }
     if (!configPath && agentPubkey) {
       throw new DaemonExitError(`unknown agent ${agentPubkey}: no durable runtime exists; refusing systemd restart loop`, UNKNOWN_AGENT_EXIT_STATUS);
     }
     if (!configPath)
       throw new Error("daemon requires --config <runtime.json> or --agent <pubkey>");
-    await runStoredDaemon(resolve20(configPath));
+    await runStoredDaemon(resolve21(configPath));
     return;
   }
   if (command === "update") {
@@ -17695,7 +18096,7 @@ async function main() {
     if (!agentPubkey)
       throw new Error("stop requires --agent <pubkey>");
     const configs = await findAgentRuntimeConfigPaths(process.env, process.cwd());
-    const configPath = configs.find((candidate) => dirname12(candidate).endsWith(agentPubkey));
+    const configPath = configs.find((candidate) => dirname13(candidate).endsWith(agentPubkey));
     if (!configPath)
       throw new Error(`no stored runtime found for agent ${agentPubkey}`);
     const runtime = await readRuntimeRecord(configPath);
@@ -17719,6 +18120,8 @@ main().catch(async (err) => {
   const interactiveUi = process.argv[2] !== "daemon" && Boolean(stdin4.isTTY && stdout5.isTTY);
   if (interactiveUi) {
     cancel(err instanceof Error ? err.message : String(err));
+  } else if (err instanceof Error && err.name === "ConnectFailureError" && (process.argv[2] === "connect" || process.argv[2] === "connect-finish")) {
+    console.error(import_picocolors3.default.red(err.message));
   } else {
     console.error(import_picocolors3.default.red("[body] fatal:"), err);
   }