usebeeline 0.0.90 → 0.0.92

package/dist/usebeeline.mjs

@@ -2415,7 +2415,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes7, createHash: createHash8 } = __require("crypto");
+    var { randomBytes: randomBytes7, createHash: createHash9 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -3083,7 +3083,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3452,7 +3452,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash8 } = __require("crypto");
+    var { createHash: createHash9 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3759,7 +3759,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest = createHash9("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3984,14 +3984,14 @@ __export(self_update_exports, {
   writeUpdateAttemptFixture: () => writeUpdateAttemptFixture,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash6 } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
-import { access, chmod as chmod4, lstat as lstat2, mkdir as mkdir14, open, readFile as readFile9, rename as rename3, rm as rm5, symlink as symlink2, writeFile as writeFile10 } from "node:fs/promises";
+import { createHash as createHash7 } from "node:crypto";
+import { constants as fsConstants2 } from "node:fs";
+import { access, chmod as chmod5, lstat as lstat3, mkdir as mkdir15, open, readFile as readFile10, rename as rename4, rm as rm6, symlink as symlink3, writeFile as writeFile10 } from "node:fs/promises";
 import { spawn as spawn4 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname10, join as join8, resolve as resolve21 } from "node:path";
+import { dirname as dirname11, join as join9, resolve as resolve22 } from "node:path";
 function anchorLayout(rawLibDir) {
-  const libDir = resolve21(rawLibDir);
+  const libDir = resolve22(rawLibDir);
   const segments = libDir.split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   if (idx >= 2 && segments[idx - 1] === "lib") {
@@ -4007,9 +4007,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: resolve21(libDir, "../../bin"),
+    binDir: resolve22(libDir, "../../bin"),
     libDir,
-    releasesRoot: resolve21(libDir, `../${RELEASES_SEGMENT}`)
+    releasesRoot: resolve22(libDir, `../${RELEASES_SEGMENT}`)
   };
 }
 function beelineInstallLayout(env = process.env) {
@@ -4020,7 +4020,7 @@ function beelineInstallLayout(env = process.env) {
 }
 function defaultBeelineInstallLayout(env = process.env) {
   const home = env.HOME?.trim() || homedir9();
-  return anchorLayout(resolve21(home, ".local", "lib", "beeline"));
+  return anchorLayout(resolve22(home, ".local", "lib", "beeline"));
 }
 function discoveredBeelineInstallLayout(env = process.env) {
   const explicitAnchor = env.BEELINE_INSTALL_LIB_DIR?.trim();
@@ -4028,7 +4028,7 @@ function discoveredBeelineInstallLayout(env = process.env) {
     return anchorLayout(explicitAnchor);
   const explicitBinDir = env.BEELINE_INSTALL_DIR?.trim();
   if (explicitBinDir)
-    return anchorLayout(resolve21(dirname10(resolve21(explicitBinDir)), "lib", "beeline"));
+    return anchorLayout(resolve22(dirname11(resolve22(explicitBinDir)), "lib", "beeline"));
   return defaultBeelineInstallLayout(env);
 }
 function hostPlatformKey() {
@@ -4039,13 +4039,13 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join8(bundleDir, "lib", "beeline", "bundle.json"), join8(bundleDir, "bundle.json")];
+  return [join9(bundleDir, "lib", "beeline", "bundle.json"), join9(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
   for (const candidate of bundleJsonCandidates(bundleDir)) {
     try {
-      raw = await readFile9(candidate, "utf8");
+      raw = await readFile10(candidate, "utf8");
       break;
     } catch {
     }
@@ -4063,17 +4063,17 @@ async function readBundleJson(bundleDir) {
   }
 }
 function updateStatePath(layout) {
-  return join8(layout.releasesRoot, ".state", "update-state.json");
+  return join9(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
-    return JSON.parse(await readFile9(updateStatePath(layout), "utf8"));
+    return JSON.parse(await readFile10(updateStatePath(layout), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir14(join8(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir15(join9(layout.releasesRoot, ".state"), { recursive: true });
   await writeFile10(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -4089,7 +4089,7 @@ function sanitizeReleaseId(id) {
 }
 async function pathKind(path) {
   try {
-    const info = await lstat2(path);
+    const info = await lstat3(path);
     if (info.isSymbolicLink())
       return "symlink";
     return info.isDirectory() ? "directory" : "missing";
@@ -4103,9 +4103,9 @@ async function activeReleaseId(layout) {
     return "legacy";
   if (kind === "missing")
     return void 0;
-  const { readlink } = await import("node:fs/promises");
+  const { readlink: readlink2 } = await import("node:fs/promises");
   try {
-    const target = await readlink(layout.libDir);
+    const target = await readlink2(layout.libDir);
     return sanitizeReleaseId(target.split("/").pop() ?? target);
   } catch {
     return void 0;
@@ -4155,12 +4155,12 @@ function run(command, args, timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join8(bundleDir, BUNDLE_ENTRYPOINT), join8(bundleDir, "beeline-cli.mjs")];
+  return [join9(bundleDir, BUNDLE_ENTRYPOINT), join9(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
     try {
-      await access(candidate, fsConstants.F_OK);
+      await access(candidate, fsConstants2.F_OK);
       return candidate;
     } catch {
     }
@@ -4177,18 +4177,18 @@ 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 = join8(layout.releasesRoot, releaseId);
-  const okMarker = join8(releaseDir, ".stage-ok");
+  const releaseDir = join9(layout.releasesRoot, releaseId);
+  const okMarker = join9(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
-    const recorded = await readFile9(okMarker, "utf8");
+    const recorded = await readFile10(okMarker, "utf8");
     if (recorded.trim() === published.sha256)
       return releaseId;
     previouslyVerified = true;
   } catch {
   }
-  await mkdir14(releaseDir, { recursive: true });
-  const tempArchive = join8(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  await mkdir15(releaseDir, { recursive: true });
+  const tempArchive = join9(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
     log2(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
@@ -4197,7 +4197,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (!response.ok || !response.body) {
       throw new Error(`downloading ${published.file} failed: HTTP ${response.status}`);
     }
-    const hash = createHash6("sha256");
+    const hash = createHash7("sha256");
     const chunks = [];
     for await (const chunk of response.body) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -4228,13 +4228,13 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract2.stderr}`);
     for (const relative3 of requiredBundlePaths()) {
       try {
-        await access(join8(releaseDir, relative3), fsConstants.F_OK);
+        await access(join9(releaseDir, relative3), fsConstants2.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative3}`);
       }
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join8(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
+      const probe = await run(process.execPath, [join9(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()}` : ""}`);
       }
@@ -4245,10 +4245,10 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
-      await rm5(releaseDir, { recursive: true, force: true });
+      await rm6(releaseDir, { recursive: true, force: true });
     throw error;
   } finally {
-    await rm5(tempArchive, { force: true });
+    await rm6(tempArchive, { force: true });
   }
 }
 function forwarderScript(tool) {
@@ -4268,45 +4268,45 @@ function forwarderScript(tool) {
 async function replaceFile(path, contents, mode) {
   const temp = `${path}.new-${process.pid}`;
   await writeFile10(temp, contents, { mode });
-  await chmod4(temp, mode);
-  await rename3(temp, path);
+  await chmod5(temp, mode);
+  await rename4(temp, path);
 }
 async function activateRelease(layout, releaseId) {
-  const releaseDir = join8(layout.releasesRoot, releaseId);
-  await access(join8(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
-  await mkdir14(layout.releasesRoot, { recursive: true });
-  await mkdir14(layout.binDir, { recursive: true });
+  const releaseDir = join9(layout.releasesRoot, releaseId);
+  await access(join9(releaseDir, BUNDLE_ENTRYPOINT), fsConstants2.F_OK);
+  await mkdir15(layout.releasesRoot, { recursive: true });
+  await mkdir15(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 = join8(layout.releasesRoot, legacyId);
+    const legacyDir = join9(layout.releasesRoot, legacyId);
     try {
-      await access(legacyDir, fsConstants.F_OK);
+      await access(legacyDir, fsConstants2.F_OK);
       previousReleaseId = `${legacyId}-${Date.now()}`;
-      await rename3(layout.libDir, join8(layout.releasesRoot, previousReleaseId));
-      await normalizeLegacyBundleShape(join8(layout.releasesRoot, previousReleaseId));
+      await rename4(layout.libDir, join9(layout.releasesRoot, previousReleaseId));
+      await normalizeLegacyBundleShape(join9(layout.releasesRoot, previousReleaseId));
     } catch {
-      await rename3(layout.libDir, legacyDir);
+      await rename4(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
       previousReleaseId = legacyId;
     }
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
-  await rm5(tempLink, { force: true });
-  await symlink2(join8("beeline-releases", releaseId), tempLink);
-  await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname10(layout.libDir));
+  await rm6(tempLink, { force: true });
+  await symlink3(join9("beeline-releases", releaseId), tempLink);
+  await rename4(tempLink, layout.libDir);
+  await fsyncDir(dirname11(layout.libDir));
   await writeBinForwarders(layout, releaseDir);
   return { previousReleaseId };
 }
 async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join8(bundleDir, "lib", "beeline");
+  const innerLib = join9(bundleDir, "lib", "beeline");
   let anyFlat = false;
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join8(bundleDir, name), fsConstants.F_OK);
+      await access(join9(bundleDir, name), fsConstants2.F_OK);
       anyFlat = true;
       break;
     } catch {
@@ -4314,14 +4314,14 @@ async function normalizeLegacyBundleShape(bundleDir) {
   }
   if (!anyFlat)
     return;
-  await mkdir14(innerLib, { recursive: true });
+  await mkdir15(innerLib, { recursive: true });
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join8(innerLib, name), fsConstants.F_OK);
+      await access(join9(innerLib, name), fsConstants2.F_OK);
       continue;
     } catch {
     }
-    await rename3(join8(bundleDir, name), join8(innerLib, name)).catch(() => void 0);
+    await rename4(join9(bundleDir, name), join9(innerLib, name)).catch(() => void 0);
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
@@ -4330,13 +4330,13 @@ async function writeBinForwarders(layout, activeBundleRoot) {
     ...Object.entries(FORWARDER_ALIASES).map(([alias, tool]) => [alias, tool])
   ];
   for (const [name, tool] of entries) {
-    const target = join8(activeBundleRoot, "bin", tool);
+    const target = join9(activeBundleRoot, "bin", tool);
     try {
-      await access(target, fsConstants.X_OK);
+      await access(target, fsConstants2.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join8(layout.binDir, name), forwarderScript(tool), 493);
+    await replaceFile(join9(layout.binDir, name), forwarderScript(tool), 493);
   }
 }
 async function repairInstallForwarders(layout, opts = {}) {
@@ -4345,7 +4345,7 @@ async function repairInstallForwarders(layout, opts = {}) {
   const forwarderHealthy = async (name, tool) => {
     let current;
     try {
-      current = await readFile9(join8(layout.binDir, name), "utf8");
+      current = await readFile10(join9(layout.binDir, name), "utf8");
     } catch {
       current = void 0;
     }
@@ -4358,29 +4358,29 @@ async function repairInstallForwarders(layout, opts = {}) {
   }
   if (healthy)
     return false;
-  await mkdir14(layout.binDir, { recursive: true });
+  await mkdir15(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 = join8(layout.releasesRoot, previousReleaseId);
+  const releaseDir = join9(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 rm5(tempLink, { force: true });
-  await symlink2(join8("beeline-releases", previousReleaseId), tempLink);
-  await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname10(layout.libDir));
+  await rm6(tempLink, { force: true });
+  await symlink3(join9("beeline-releases", previousReleaseId), tempLink);
+  await rename4(tempLink, layout.libDir);
+  await fsyncDir(dirname11(layout.libDir));
 }
 function updateAttemptPath(layout) {
-  return join8(layout.releasesRoot, ".state", "update-attempt.json");
+  return join9(layout.releasesRoot, ".state", "update-attempt.json");
 }
 async function readUpdateAttempt(layout) {
   try {
-    const raw = JSON.parse(await readFile9(updateAttemptPath(layout), "utf8"));
+    const raw = JSON.parse(await readFile10(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;
     }
@@ -4390,12 +4390,12 @@ async function readUpdateAttempt(layout) {
   }
 }
 async function writeUpdateAttempt(layout, record2) {
-  await mkdir14(join8(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir15(join9(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateAttemptPath(layout);
   const staged = `${path}.${process.pid}.tmp`;
   await writeFile10(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
-  await rename3(staged, path);
+  await rename4(staged, path);
 }
 async function replaceUpdateAttempt(layout, record2) {
   await writeUpdateAttempt(layout, record2);
@@ -4655,8 +4655,8 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname16, resolve as resolve29 } from "node:path";
-import { readFile as readFile14, unlink as unlink5, writeFile as writeFile16 } from "node:fs/promises";
+import { dirname as dirname17, resolve as resolve30 } from "node:path";
+import { readFile as readFile15, unlink as unlink5, writeFile as writeFile16 } from "node:fs/promises";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -7527,7 +7527,7 @@ var AcpClient = class extends EventEmitter {
     const current = this.activeRunIds.get(sessionId);
     if (current)
       return Promise.resolve(current);
-    return new Promise((resolve30, reject) => {
+    return new Promise((resolve31, reject) => {
       const onUpdate = (update) => {
         if (update.sessionId !== sessionId)
           return;
@@ -7535,7 +7535,7 @@ var AcpClient = class extends EventEmitter {
         if (!runId)
           return;
         cleanup();
-        resolve30(runId);
+        resolve31(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -7619,13 +7619,13 @@ var AcpClient = class extends EventEmitter {
     }
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve30, reject) => {
+    return new Promise((resolve31, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart), detail));
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: resolve30,
+        resolve: resolve31,
         reject,
         timer,
         method,
@@ -17164,10 +17164,10 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 
 // apps/body/dist/room-runtime.js
 import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
-import { mkdir as mkdir12, rm as rm4 } from "node:fs/promises";
-import { dirname as dirname7, resolve as resolve19 } from "node:path";
+import { mkdir as mkdir13, rm as rm5 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve20 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // apps/body/dist/grant-runner.js
@@ -17449,7 +17449,7 @@ var KNOWN_CREDENTIAL_MASK_PATHS = [
   ".git-credentials",
   ".secrets.env"
 ];
-function credentialMaskPaths(extraPaths, home = homedir3(), stat3 = (path) => {
+function credentialMaskPaths(extraPaths, home = homedir3(), stat4 = (path) => {
   try {
     const info = lstatSync2(path);
     return { isDirectory: info.isDirectory() };
@@ -17468,7 +17468,7 @@ function credentialMaskPaths(extraPaths, home = homedir3(), stat3 = (path) => {
     if (seen.has(path))
       continue;
     seen.add(path);
-    const info = stat3(path);
+    const info = stat4(path);
     if (!info) {
       if (required.has(path))
         masks.push({ path, kind: "dir", create: true });
@@ -18137,13 +18137,13 @@ async function runServerCommandIntake(options) {
         }
       }
       options.onPoll?.();
-      const reconcile = await new Promise((resolve30) => {
+      const reconcile = await new Promise((resolve31) => {
         const done = (needed) => {
           if (timer)
             clearTimeout(timer);
           signal?.removeEventListener("abort", aborted);
           wake = void 0;
-          resolve30(needed);
+          resolve31(needed);
         };
         const aborted = () => done(false);
         wake = done;
@@ -18169,10 +18169,10 @@ async function runServerCommandIntake(options) {
 
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile4 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir11 } from "node:fs/promises";
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir as mkdir12 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // apps/body/dist/agent-home.js
@@ -18995,7 +18995,7 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     console.warn("[body] operator MCP passthrough failed for claude:", error);
   }
   try {
-    const settings2 = { permissions: { allow: ["WebSearch"] } };
+    const settings2 = { permissions: { allow: ["WebSearch", "WebFetch"] } };
     await writeIsolatedHarnessFile(resolve13(root, "claude", "settings.json"), `${JSON.stringify(settings2, null, 2)}
 `);
   } catch (error) {
@@ -19559,18 +19559,6 @@ function sanitizeAgentReply(message) {
   }
   return lines.slice(1).join("\n").trim();
 }
-var CORNER_OPEN_ECHO = /^(?:(?:ok(?:ay)?|done|sure|great|alright)[,.!:]?\s+)?(?:i(?:'ve| have|'ll| will|'m| am)?\s+)?(?:just\s+)?open(?:ed|ing)?\s+(?:up\s+)?(?:a\s+|the\s+|your\s+)?(?:new\s+|write(?:-enabled)?\s+|repository\s+)*corner\b/iu;
-var CORNER_OPEN_ECHO_MAX_CHARS = 320;
-function stripCornerOpenEcho(message) {
-  const visible = message.trim();
-  if (!visible)
-    return "";
-  const paragraphs = visible.split(/\n\s*\n/);
-  const first = paragraphs[0].trim();
-  if (first.length > CORNER_OPEN_ECHO_MAX_CHARS || !CORNER_OPEN_ECHO.test(first))
-    return visible;
-  return paragraphs.slice(1).join("\n\n").trim();
-}
 var STATUS_FILLER = new Set("a an the this that it its is are was were be been being has have had do does did now still remains remain remaining ready for review reviewing pr pull request all every both and or so to of in on at as with by no not nothing new further more else needed needs need required action actions change changes changed status state update updates updated waiting wait awaiting pending running progress idle done ok okay good great well fine confirmed confirm already again yet just currently right i we will can should would github remote upstream branch head latest current report reported noted note see looks look like everything nothing appears appear seems seem there here which what from without any".split(/\s+/));
 var STATUS_SYNONYMS = {
   passed: ["pass", "passed", "passing", "passes", "green", "succeeded", "success", "successful", "successfully"],
@@ -20792,16 +20780,299 @@ process.exit(result.status ?? 1);
   await chmod3(path, 448);
 }
 
+// apps/body/dist/warm-node-modules.js
+import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { chmod as chmod4, copyFile as copyFile2, link, lstat as lstat2, mkdir as mkdir10, readdir as readdir5, readFile as readFile8, readlink, rename as rename3, rm as rm4, stat as stat2, symlink as symlink2, utimes } from "node:fs/promises";
+import { dirname as dirname7, join as join6, resolve as resolve19 } from "node:path";
+var STORE_FORMAT = "v1";
+var STAGING_PREFIX = ".beeline-warm-";
+var STAGING_SWEEP_MS = 24 * 60 * 60 * 1e3;
+var WARM_STORE_MAX_ENTRIES = 3;
+function sharedNpmCacheDir(supervisorRoot) {
+  return resolve19(supervisorRoot, "beeline", "npm-cache");
+}
+function warmNodeModulesStoreDir(supervisorRoot) {
+  return resolve19(supervisorRoot, "beeline", "node-modules");
+}
+function isPlanRefusal(value) {
+  return "failure" in value;
+}
+async function readWarmPlan(worktreePath) {
+  const lockfile = await readFile8(resolve19(worktreePath, "package-lock.json")).catch(() => void 0);
+  if (!lockfile)
+    return { failure: "no-lockfile" };
+  const packages = parseLockfilePackages(lockfile);
+  if (!packages)
+    return { failure: "no-lockfile" };
+  const escaping = Object.keys(packages).find((path) => namesInstalledPackage(path) && !isContainedPath(path));
+  if (escaping)
+    return { failure: "unsafe-lockfile", detail: escaping };
+  const trees = nodeModulesTreePaths(packages);
+  if (trees.length === 0)
+    return { failure: "no-lockfile" };
+  const unsafe = trees.find((tree) => !isContainedTreePath(tree));
+  if (unsafe)
+    return { failure: "unsafe-lockfile", detail: unsafe };
+  const key = createHash4("sha256").update(`${STORE_FORMAT}\0${process.platform}\0${process.arch}\0${process.versions.modules}\0`).update(lockfile).digest("hex").slice(0, 32);
+  return { key, trees };
+}
+function nodeModulesTreePaths(packages) {
+  const trees = /* @__PURE__ */ new Set();
+  for (const path of Object.keys(packages)) {
+    if (!namesInstalledPackage(path))
+      continue;
+    const segments = path.split("/");
+    trees.add(segments.slice(0, segments.indexOf("node_modules") + 1).join("/"));
+  }
+  return [...trees].sort();
+}
+function namesInstalledPackage(path) {
+  const segments = path.split("/");
+  const index = segments.indexOf("node_modules");
+  return index >= 0 && index < segments.length - 1;
+}
+async function seedWarmNodeModules(input) {
+  const plan = await readWarmPlan(input.worktreePath);
+  if (isPlanRefusal(plan)) {
+    return { reason: plan.failure, ...plan.detail ? { detail: plan.detail } : {} };
+  }
+  for (const tree of plan.trees) {
+    if (await pathExists(resolve19(input.worktreePath, tree))) {
+      return { reason: "present", key: plan.key };
+    }
+  }
+  const entry = resolve19(input.storeRoot, plan.key);
+  if (!await isDirectory(entry))
+    return { reason: "cold", key: plan.key };
+  const [storeDevice, checkoutDevice] = await Promise.all([
+    deviceOf(entry),
+    deviceOf(input.worktreePath)
+  ]);
+  if (storeDevice === void 0 || storeDevice !== checkoutDevice) {
+    return { reason: "cross-device", key: plan.key };
+  }
+  const staging = resolve19(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID4()}`);
+  const placed = [];
+  const now2 = (input.now ?? Date.now)();
+  try {
+    await sweepStaleStaging(input.storeRoot, now2);
+    await utimes(entry, now2 / 1e3, now2 / 1e3).catch(() => void 0);
+    for (const tree of plan.trees) {
+      await cloneTree(resolve19(entry, tree), resolve19(staging, tree), seedFile);
+    }
+    for (const tree of plan.trees) {
+      const target = resolve19(input.worktreePath, tree);
+      await mkdir10(dirname7(target), { recursive: true });
+      await rename3(resolve19(staging, tree), target);
+      placed.push(target);
+    }
+    return { reason: "seeded", key: plan.key };
+  } catch (error) {
+    for (const target of placed) {
+      await rm4(target, { recursive: true, force: true }).catch(() => void 0);
+    }
+    return { reason: "failed", key: plan.key, detail: describe(error) };
+  } finally {
+    await rm4(staging, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function harvestWarmNodeModules(input) {
+  const plan = await readWarmPlan(input.worktreePath);
+  if (isPlanRefusal(plan)) {
+    return { reason: plan.failure, ...plan.detail ? { detail: plan.detail } : {} };
+  }
+  const entry = resolve19(input.storeRoot, plan.key);
+  if (await pathExists(entry))
+    return { reason: "already-warm", key: plan.key };
+  for (const tree of plan.trees) {
+    if (!await isDirectory(resolve19(input.worktreePath, tree))) {
+      return { reason: "no-node-modules", key: plan.key, detail: tree };
+    }
+  }
+  const missing = await missingInstalledPackages(input.worktreePath);
+  if (missing.length > 0) {
+    return {
+      reason: "incomplete",
+      key: plan.key,
+      detail: `${missing.length} absent, e.g. ${missing.slice(0, 3).join(", ")}`
+    };
+  }
+  const staging = resolve19(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID4()}`);
+  try {
+    await mkdir10(input.storeRoot, { recursive: true, mode: 493 });
+    await sweepStaleStaging(input.storeRoot, (input.now ?? Date.now)());
+    for (const tree of plan.trees) {
+      await cloneTree(resolve19(input.worktreePath, tree), resolve19(staging, tree), harvestFile);
+    }
+    await input.onCopied?.();
+    if (!await stagedTreeIsPublishable(input.worktreePath, staging, plan.key)) {
+      return { reason: "changed", key: plan.key };
+    }
+    await rename3(staging, entry);
+    await pruneWarmStore(input.storeRoot, WARM_STORE_MAX_ENTRIES);
+    return { reason: "stored", key: plan.key };
+  } catch (error) {
+    if (await pathExists(entry))
+      return { reason: "already-warm", key: plan.key };
+    return { reason: "failed", key: plan.key, detail: describe(error) };
+  } finally {
+    await rm4(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 = join6("node_modules", ".package-lock.json");
+  const [copied, current] = await Promise.all([
+    readFile8(resolve19(staging, hidden)).catch(() => void 0),
+    readFile8(resolve19(worktreePath, hidden)).catch(() => void 0)
+  ]);
+  if (!copied || !current || !copied.equals(current))
+    return false;
+  return (await missingInstalledPackages(worktreePath, staging)).length === 0;
+}
+async function missingInstalledPackages(worktreePath, treeRoot = worktreePath) {
+  const wanted = parseLockfilePackages(await readFile8(resolve19(worktreePath, "package-lock.json")).catch(() => void 0));
+  const installed = parseLockfilePackages(await readFile8(resolve19(treeRoot, "node_modules", ".package-lock.json")).catch(() => void 0));
+  if (!wanted)
+    return ["package-lock.json is unreadable"];
+  if (!installed)
+    return ["node_modules/.package-lock.json is absent"];
+  const required = [];
+  const missing = [];
+  for (const [path, entry] of Object.entries(wanted)) {
+    if (!namesInstalledPackage(path))
+      continue;
+    if (entry.link === true || entry.optional === true)
+      continue;
+    if (entry.os !== void 0 || entry.cpu !== void 0)
+      continue;
+    if (!isContainedPath(path))
+      missing.push(path);
+    else
+      required.push(path);
+  }
+  await mapWithLimit(required, INTEGRITY_READ_CONCURRENCY, async (path) => {
+    if (!(path in installed) || !await isInstalledPackage(resolve19(treeRoot, path))) {
+      missing.push(path);
+    }
+  });
+  return missing.sort();
+}
+async function isInstalledPackage(path) {
+  return stat2(join6(path, "package.json")).then((info) => info.isFile(), () => false);
+}
+var INTEGRITY_READ_CONCURRENCY = 64;
+async function mapWithLimit(values, limit, visit) {
+  let cursor3 = 0;
+  await Promise.all(Array.from({ length: Math.min(limit, values.length) }, async () => {
+    while (cursor3 < values.length)
+      await visit(values[cursor3++]);
+  }));
+}
+function parseLockfilePackages(source) {
+  if (!source)
+    return void 0;
+  try {
+    const parsed = JSON.parse(source.toString("utf8"));
+    const packages = parsed.packages;
+    if (!packages || typeof packages !== "object" || Array.isArray(packages))
+      return void 0;
+    return packages;
+  } catch {
+    return void 0;
+  }
+}
+function isContainedPath(value) {
+  if (!value)
+    return false;
+  return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== ".." && !segment.includes("\\"));
+}
+function isContainedTreePath(value) {
+  return isContainedPath(value) && value.split("/").pop() === "node_modules";
+}
+async function cloneTree(source, target, file, topLevel = true) {
+  await mkdir10(target, { recursive: true, mode: 493 });
+  for (const entry of await readdir5(source, { withFileTypes: true })) {
+    const from = join6(source, entry.name);
+    const to = join6(target, entry.name);
+    if (entry.isSymbolicLink()) {
+      await symlink2(await readlink(from), to);
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await cloneTree(from, to, file, false);
+      continue;
+    }
+    if (entry.isFile())
+      await file(from, to, topLevel);
+  }
+}
+var harvestFile = async (source, target) => {
+  await copyFile2(source, target, fsConstants.COPYFILE_FICLONE);
+  const info = await stat2(source);
+  await chmod4(target, info.mode & 4095 & ~146);
+};
+var seedFile = async (source, target, topLevel) => {
+  if (!topLevel) {
+    await link(source, target);
+    return;
+  }
+  await copyFile2(source, target);
+  await chmod4(target, 420);
+};
+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 lstat2(join6(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(join6(storeRoot, entry.name), { recursive: true, force: true }).catch(() => void 0);
+  }
+  return dropped.map((entry) => entry.name);
+}
+async function sweepStaleStaging(storeRoot, now2) {
+  const entries = await readdir5(storeRoot).catch(() => []);
+  for (const name of entries) {
+    if (!name.startsWith(STAGING_PREFIX))
+      continue;
+    const path = join6(storeRoot, name);
+    const info = await lstat2(path).catch(() => void 0);
+    if (!info || now2 - info.mtimeMs < STAGING_SWEEP_MS)
+      continue;
+    await rm4(path, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function pathExists(path) {
+  return lstat2(path).then(() => true, () => false);
+}
+async function deviceOf(path) {
+  return stat2(path).then((info) => info.dev, () => void 0);
+}
+async function isDirectory(path) {
+  return stat2(path).then((info) => info.isDirectory(), () => false);
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // apps/body/dist/monolith-room-turn.js
-import { mkdir as mkdir10 } from "node:fs/promises";
+import { mkdir as mkdir11 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // packages/api-contract/dist/scheduled-prompts.js
 var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
 var SCHEDULE_RAN_VERB = "ran a schedule for";
 
 // apps/body/dist/monolith-room-turn.js
+var ROOM_PROMPT_INACTIVITY_TIMEOUT_MS = 18e4;
 function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
   if (isSquireMcpPermissionRequest(request))
     return false;
@@ -20836,12 +21107,11 @@ function roomMentionDirectory(roster, selfId) {
     if (member.identityId === selfId)
       continue;
     const handle = member.handle?.trim().replace(/^@/, "");
-    const name = member.name?.trim() ?? "";
-    const alias = handle || name;
-    if (!alias)
+    if (!handle)
       continue;
+    const name = member.name?.trim() ?? "";
     const kind = member.kind === "agent" ? "agent" : "person";
-    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
+    rows.push(`- @${handle}${name && name !== handle ? ` \u2014 ${name}` : ""} (${kind})`);
   }
   if (!rows.length)
     return "";
@@ -20852,47 +21122,6 @@ function roomMentionDirectory(roster, selfId) {
     "Write a tag exactly as spelled here. An @name spelled any other way is plain text: it reaches nobody, and nobody is told it was meant for them. Never invent a handle, shorten one, or copy an @name out of the conversation \u2014 old messages carry spellings that no longer exist."
   ].join("\n");
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function agentReplyMentionIds(text2, roster, authorId) {
-  const aliases = /* @__PURE__ */ new Map();
-  for (const member of roster.members) {
-    if (member.identityId === authorId)
-      continue;
-    const rawAliases = member.kind === "agent" ? [member.handle] : [member.name, member.handle, member.soul?.name];
-    for (const raw of rawAliases) {
-      const display = raw?.trim().replace(/^@/, "");
-      if (!display)
-        continue;
-      const key = display.toLocaleLowerCase();
-      const entry = aliases.get(key) ?? { display, ids: /* @__PURE__ */ new Set() };
-      entry.ids.add(member.identityId);
-      aliases.set(key, entry);
-    }
-  }
-  for (const member of roster.members) {
-    if (member.identityId === authorId || member.kind === "agent" || !member.handle)
-      continue;
-    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
-    const canonical = aliases.get(handle);
-    const legacy = `a_${handle}`;
-    if (canonical && !aliases.has(legacy))
-      aliases.set(legacy, { ...canonical, display: legacy });
-  }
-  const mentioned = [];
-  for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
-    if (ids.size !== 1)
-      continue;
-    const pattern = new RegExp(`(^|[\\s([{])@${escapeRegExp(display)}(?=$|[\\s.,!?;:)\\]}])`, "iu");
-    if (!pattern.test(text2))
-      continue;
-    const identityId = [...ids][0];
-    if (!mentioned.includes(identityId))
-      mentioned.push(identityId);
-  }
-  return mentioned;
-}
 var MonolithRoomTurnLoop = class {
   options;
   commandContext;
@@ -21039,7 +21268,7 @@ var MonolithRoomTurnLoop = class {
     const cached = this.deliveredAttachments.get(item.id);
     if (cached)
       return cached;
-    const delivered = await deliverAttachments(item.attachments, join6(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
+    const delivered = await deliverAttachments(item.attachments, join7(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
     this.deliveredAttachments.set(item.id, withoutImageData(delivered));
     return delivered;
   }
@@ -21106,7 +21335,7 @@ var MonolithRoomTurnLoop = class {
       agentName: self?.name ?? this.agent.name
     });
     const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
-    await mkdir10(this.options.cwd, { recursive: true });
+    await mkdir11(this.options.cwd, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
@@ -21132,14 +21361,14 @@ var MonolithRoomTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir6();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join6(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join7(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     this.sessionStateDirs = stateDirs;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir10(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir11(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
     if (attachScratchRoot)
-      await mkdir10(attachScratchRoot, { recursive: true });
+      await mkdir11(attachScratchRoot, { recursive: true });
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
@@ -21403,7 +21632,7 @@ var MonolithRoomTurnLoop = class {
               try {
                 stream.beginRun();
                 trace.promptSent();
-                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
+                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, ROOM_PROMPT_INACTIVITY_TIMEOUT_MS, (delta, full) => {
                   trace.firstModelOutput();
                   stream.onChunk(delta, full);
                 }, void 0, (calls) => trace.toolCalls(calls));
@@ -21476,12 +21705,10 @@ var MonolithRoomTurnLoop = class {
             console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
           }
           if (openCornerCall && !isFailedToolCall(openCornerCall)) {
-            reply = stripCornerOpenEcho(reply);
+            reply = "";
           }
-          const mentionIds = reply ? agentReplyMentionIds(reply, roster, this.agent.publicKey) : [];
           await trace.measure("publish", () => stream.settle(reply, reply ? {
-            triggerMessageId: item.id,
-            mentionIds
+            triggerMessageId: item.id
           } : {}));
         }, { priority: "interactive", roomKey: this.options.roomId });
       }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
@@ -21563,7 +21790,42 @@ var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
 function cornerMergeInstruction(yoloMode) {
-  return yoloMode ? "Yolo mode is on: when that merge gate passes, merge this pull request yourself with gh." : "Yolo mode is off: never merge the pull request yourself; leave it for human approval in the app.";
+  return yoloMode ? "Yolo is on: when the gate passes, merge this pull request with gh." : "Yolo is off: never merge; wait for explicit human approval in the app.";
+}
+var CORNER_DELIVERY_NUDGE = "Before ending this turn, inspect the repository state and finish delivering the work: commit and push the intended changes and open the pull request if one does not exist. Decide yourself whether any remaining dirty work belongs to the objective; do not discard it merely to make the worktree clean.";
+var CORNER_YOLO_MERGE_NUDGE = 'Yolo is on. Check the server merge gate with pr_checks_status now and, if checks="passed", held=false, and approvalPending=false, merge this pull request with gh. Otherwise stop without merging.';
+function isCornerChecksTurn(trigger, restates) {
+  return Boolean(restates) || /\b(?:passed|failed) a check\b/i.test(trigger);
+}
+async function cornerUndeliveredRepositoryState(worktreePath, featureBranch, targetBranch) {
+  try {
+    const [{ stdout: status }, ahead] = await Promise.all([
+      execFileAsync3("git", ["-C", worktreePath, "status", "--porcelain=v1"]),
+      featureBranch ? firstResolvedRemoteRef(worktreePath, [featureBranch, targetBranch]).then((remoteRef) => remoteRef ? execFileAsync3("git", [
+        "-C",
+        worktreePath,
+        "rev-list",
+        "--count",
+        `${remoteRef}..HEAD`
+      ]).then(({ stdout: stdout6 }) => Number.parseInt(stdout6.trim(), 10) || 0) : 0).catch(() => 0) : Promise.resolve(0)
+    ]);
+    const dirty = status.trimEnd();
+    return dirty || ahead > 0 ? `${dirty}
+ahead:${ahead}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function firstResolvedRemoteRef(worktreePath, branches) {
+  for (const branch of branches) {
+    if (!branch)
+      continue;
+    const ref = `refs/remotes/origin/${branch}`;
+    const resolved = await execFileAsync3("git", ["-C", worktreePath, "rev-parse", "--verify", ref]).then(() => true).catch(() => false);
+    if (resolved)
+      return ref;
+  }
+  return void 0;
 }
 function oneLine(value) {
   return value.replace(/\s+/g, " ").trim();
@@ -21650,7 +21912,7 @@ function toolArguments(call) {
   return input ? { input: clampBytes(redactToolDetail(input), TOOL_ARGUMENT_MAX_BYTES) } : {};
 }
 function toolCallKey(call, index) {
-  return call.id ? `id-${createHash4("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
+  return call.id ? `id-${createHash5("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
 }
 function toolCallSettled(call) {
   if (call.resultReceived)
@@ -21713,6 +21975,10 @@ var MonolithCornerTurnLoop = class {
   modelTakesImages;
   /** The one provider re-pinned after an empty completion, until the session ends. */
   pinnedProviderOverride;
+  /** The merge authority baked into the current session. */
+  yoloMode = false;
+  /** Repository state already given a delivery reminder, until that state changes. */
+  lastDeliveryNudgeState;
   turnIdentityInstructions = "";
   busy = false;
   forcedStop = false;
@@ -21737,6 +22003,8 @@ var MonolithCornerTurnLoop = class {
    * by the same replay window the inbox already de-duplicates over.
    */
   stoppedTurns = /* @__PURE__ */ new Set();
+  /** In-flight warm-store harvest, awaited at shutdown and never by a turn. */
+  harvest;
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
@@ -21848,7 +22116,8 @@ var MonolithCornerTurnLoop = class {
       agentName: self?.name ?? this.agent.name,
       yoloMode: configuration.yoloMode
     });
-    await mkdir11(this.options.worktreePath, { recursive: true });
+    this.yoloMode = configuration.yoloMode;
+    await mkdir12(this.options.worktreePath, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
@@ -21880,10 +22149,13 @@ var MonolithCornerTurnLoop = class {
         inheritedPath: this.options.config.agentEnv.PATH ?? process.env.PATH
       });
     }
+    const npmCacheDir = sharedNpmCacheDir(this.options.runtime.supervisorRoot);
+    await mkdir12(npmCacheDir, { recursive: true, mode: 448 });
     const agentEnv = {
       ...this.options.config.agentEnv,
       ...homeOverlay,
-      ...githubEnv
+      ...githubEnv,
+      npm_config_cache: npmCacheDir
     };
     this.agentEnv = agentEnv;
     const agentArgs = agentArgsWithModelSelection({
@@ -21893,13 +22165,13 @@ var MonolithCornerTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir7();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join7(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join8(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir11(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir12(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
     if (attachScratchRoot)
-      await mkdir11(attachScratchRoot, { recursive: true });
+      await mkdir12(attachScratchRoot, { recursive: true });
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
@@ -21911,7 +22183,13 @@ var MonolithCornerTurnLoop = class {
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
         ...tmpDir ? { tmpDir } : {},
-        ...attachScratchRoot ? { additionalWritablePaths: [attachScratchRoot] } : {},
+        additionalWritablePaths: [
+          ...attachScratchRoot ? [attachScratchRoot] : [],
+          // The shared npm cache. npm writes to its cache on every install,
+          // and this one is deliberately outside the per-corner home so the
+          // download is paid once per host rather than once per corner.
+          npmCacheDir
+        ],
         maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, operatorHome)
       },
       command,
@@ -21940,7 +22218,11 @@ var MonolithCornerTurnLoop = class {
           // the corner harness without inheriting any host credentials.
           env: [
             { name: "GH_TOKEN", value: repository.githubToken },
-            { name: "GITHUB_TOKEN", value: repository.githubToken }
+            { name: "GITHUB_TOKEN", value: repository.githubToken },
+            // Its shell tool runs the same installs the harness does, and
+            // a sanitized env would otherwise send them to npm's default
+            // per-corner cache.
+            { name: "npm_config_cache", value: npmCacheDir }
           ]
         }
       ] : [],
@@ -21977,13 +22259,11 @@ var MonolithCornerTurnLoop = class {
         personaInstructions,
         ...repository ? [
           `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
-          `Work normally, then commit and push only ${repository.featureBranch}; never force-push or write to ${repository.targetBranch}. Open its pull request with gh. Before each push, rebase on origin/${repository.featureBranch}; resolve conflicts autonomously and rerun affected tests.`,
-          "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.",
-          'On a later server checks turn, call beeline-agent pr_checks_status. Never merge unless it returns checks="passed", held=false, and approvalPending=false; a human hold remains until a later human explicitly resumes.',
+          `Commit and push only ${repository.featureBranch}; never force-push or write to ${repository.targetBranch}. Before pushing, rebase on origin/${repository.featureBranch}; resolve conflicts autonomously, realigning to that remote branch and redoing the objective if needed, then rerun affected tests. Open the pull request with gh.`,
+          'Once the pull request exists, reply only with its full URL and end the turn; do not check or wait for CI. On a later checks turn, call pr_checks_status. Merge only when checks="passed", held=false, and approvalPending=false; only a later explicit human resume clears a hold.',
           cornerMergeInstruction(configuration.yoloMode),
           "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
-          'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
-          "When approval is pending, wait for the server close request. Never merge a different pull request."
+          "Never restate server check or merge notes. On a checks turn, say nothing unless you merge or push a fix, then use one short line. When approval is pending, wait for the server close request. Never merge another pull request."
         ] : [
           "This is a chat-only corner with no repository or GitHub workflow.",
           "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
@@ -22102,7 +22382,7 @@ var MonolithCornerTurnLoop = class {
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
             api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join7(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join8(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
           ]));
           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;
@@ -22204,7 +22484,7 @@ ${trigger}`,
             publishToolCalls(calls, false);
             await this.activityTail;
           };
-          const runPrompt = async () => {
+          const runPrompt = async (prompt = buildPrompt()) => {
             activityAttempt += 1;
             publishedToolCalls.clear();
             observedToolCalls.clear();
@@ -22216,7 +22496,7 @@ ${trigger}`,
             narrationRunBoundary = 0;
             currentNarrationRun = "";
             trace.promptSent();
-            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full, currentRun, runs) => {
+            return this.client.sessionPrompt(this.sessionId, promptWithImages(prompt, attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full, currentRun, runs) => {
               trace.firstModelOutput();
               if (runs) {
                 completedNarrationRuns = runs.slice(narrationRunBoundary);
@@ -22248,6 +22528,19 @@ ${trigger}`,
               explained = await this.explainEmpty(result);
             }
           }
+          const checksTurn = isCornerChecksTurn(trigger, restates);
+          const deliveryState = !checksTurn && this.options.repository ? await cornerUndeliveredRepositoryState(this.options.worktreePath, this.options.repository.featureBranch, this.options.repository.targetBranch) : void 0;
+          const needsDeliveryNudge = deliveryState !== void 0 && deliveryState !== this.lastDeliveryNudgeState;
+          let replyBeforeNudge = "";
+          if (!explained && (needsDeliveryNudge || checksTurn && this.yoloMode)) {
+            if (needsDeliveryNudge)
+              this.lastDeliveryNudgeState = deliveryState;
+            replyBeforeNudge = durableReplyText(result.agentText);
+            await flushToolCalls(result.toolCalls, "");
+            result = await runPrompt(checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
+            trace.promptSettled();
+            explained = await this.explainEmpty(result);
+          }
           if (this.stoppedTurns.has(requestId)) {
             stream.close();
             throw new TurnStoppedError("turn stopped by the requester");
@@ -22255,6 +22548,7 @@ ${trigger}`,
           let reply = durableReplyText(result.agentText);
           if (!reply && explained?.recoveredText)
             reply = durableReplyText(explained.recoveredText);
+          reply = [replyBeforeNudge, reply].filter(Boolean).join("\n\n");
           await flushToolCalls(result.toolCalls, reply);
           for (const call of result.toolCalls) {
             const failure = toolCallFailureLine(call);
@@ -22269,10 +22563,8 @@ ${trigger}`,
             console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
           }
           const durableReply = spoken(reply);
-          const mentionIds = durableReply ? agentReplyMentionIds(durableReply, roster, this.agent.publicKey) : [];
           await trace.measure("publish", () => stream.settle(durableReply, durableReply ? {
-            ...requestedById ? { triggerMessageId: requestId } : {},
-            mentionIds
+            ...requestedById ? { triggerMessageId: requestId } : {}
           } : {}));
         }, { priority: "interactive", roomKey: cornerId });
       }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
@@ -22304,8 +22596,39 @@ ${trigger}`,
     } finally {
       this.busy = false;
       this.currentTurn = void 0;
+      this.harvestWarmNodeModules();
     }
   }
+  /**
+   * Offer this worktree's `node_modules` to the host-wide warm store.
+   *
+   * A turn's end is the moment the tree is most likely to be a finished
+   * install, and the store keeps only the first complete tree per lockfile —
+   * so after the first corner on a lockfile this is one `stat` that answers
+   * `already-warm`. The copy that the first one does is deliberately NOT
+   * awaited by the turn: nobody in the Room is waiting on a cache, and the
+   * only thing that waits is shutdown, so a half-copied tree is never left
+   * where a later corner could read it as complete.
+   */
+  harvestWarmNodeModules() {
+    if (this.harvest || !this.options.repository)
+      return;
+    const { cornerId, worktreePath, runtime } = this.options;
+    const run2 = harvestWarmNodeModules({
+      worktreePath,
+      storeRoot: warmNodeModulesStoreDir(runtime.supervisorRoot)
+    }).then((outcome) => {
+      if (outcome.reason === "already-warm" || outcome.reason === "no-lockfile")
+        return;
+      console.log(`[thin-core] corner ${cornerId} warm node_modules harvest: ${outcome.reason}${outcome.detail ? ` (${outcome.detail})` : ""}`);
+    }).catch((error) => {
+      console.error(`[thin-core] corner ${cornerId} warm node_modules harvest failed:`, error);
+    }).finally(() => {
+      if (this.harvest === run2)
+        this.harvest = void 0;
+    });
+    this.harvest = run2;
+  }
   /**
    * Bring this worktree onto the corner's branch as GitHub currently has it,
    * before any work is done on top of it.
@@ -22352,6 +22675,7 @@ ${trigger}`,
           const state = await api.execute("getCornerRestoreState", { cornerId });
           if (!state.closeRequested)
             return false;
+          await this.harvest;
           await this.options.onCloseRequested();
           return true;
         },
@@ -22360,6 +22684,7 @@ ${trigger}`,
     } finally {
       this.options.grantRunner?.unregister(cornerId);
       await this.options.scheduler.suspend(cornerId);
+      await this.harvest;
     }
   }
 };
@@ -22780,13 +23105,13 @@ function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
 }
 async function materializeCornerWorktree(input) {
   const remote = roomCheckoutRemote(input.remote);
-  const repositoryHash = createHash5("sha256").update(remote).digest("hex").slice(0, 24);
-  const gitCommonDir = resolve19(input.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
-  const path = resolve19(input.supervisorRoot, "beeline", "corners", input.cornerId);
-  await mkdir12(dirname7(gitCommonDir), { recursive: true, mode: 448 });
-  await mkdir12(dirname7(path), { recursive: true, mode: 448 });
+  const repositoryHash = createHash6("sha256").update(remote).digest("hex").slice(0, 24);
+  const gitCommonDir = resolve20(input.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
+  const path = resolve20(input.supervisorRoot, "beeline", "corners", input.cornerId);
+  await mkdir13(dirname8(gitCommonDir), { recursive: true, mode: 448 });
+  await mkdir13(dirname8(path), { recursive: true, mode: 448 });
   const authEnv = githubGitEnv(input.token);
-  if (!existsSync4(resolve19(gitCommonDir, "HEAD"))) {
+  if (!existsSync4(resolve20(gitCommonDir, "HEAD"))) {
     await execFileAsync4("git", ["clone", "--bare", remote, gitCommonDir], {
       env: authEnv,
       maxBuffer: 4 * 1024 * 1024
@@ -22805,8 +23130,8 @@ async function materializeCornerWorktree(input) {
     "origin",
     `+refs/heads/${input.featureBranch}:refs/remotes/origin/${input.featureBranch}`
   ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 }).then(() => true, () => false);
-  if (!existsSync4(resolve19(path, ".git"))) {
-    await rm4(path, { recursive: true, force: true });
+  if (!existsSync4(resolve20(path, ".git"))) {
+    await rm5(path, { recursive: true, force: true });
     await execFileAsync4("git", [
       `--git-dir=${gitCommonDir}`,
       "worktree",
@@ -22816,6 +23141,13 @@ async function materializeCornerWorktree(input) {
       path,
       restored ? `refs/remotes/origin/${input.featureBranch}` : `refs/remotes/origin/${input.targetBranch}`
     ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
+    const seed = await seedWarmNodeModules({
+      worktreePath: path,
+      storeRoot: warmNodeModulesStoreDir(input.supervisorRoot)
+    });
+    if (seed.reason !== "no-lockfile") {
+      console.log(`[thin-core] corner ${input.cornerId} warm node_modules: ${seed.reason}${seed.detail ? ` (${seed.detail})` : ""}`);
+    }
   }
   await execFileAsync4("git", [
     `--git-dir=${gitCommonDir}`,
@@ -22849,7 +23181,7 @@ async function materializeCornerWorktree(input) {
     `${input.committer.publicKey.slice(0, 16)}@users.noreply.github.com`
   ]);
   const top = await execFileAsync4("git", ["-C", path, "rev-parse", "--show-toplevel"]);
-  if (resolve19(top.stdout.trim()) !== resolve19(path)) {
+  if (resolve20(top.stdout.trim()) !== resolve20(path)) {
     throw new Error(`corner worktree escaped its isolated root: ${top.stdout.trim()}`);
   }
   return { path, gitCommonDir };
@@ -22915,11 +23247,11 @@ async function removeCornerWorktreeAndBranches(worktree) {
 }
 var execFileAsync4 = promisify4(execFile5);
 async function removeCornerScratchWorkspace(input) {
-  const expected = resolve19(input.roomRoot, "scratch");
-  if (resolve19(input.scratchPath) !== expected) {
+  const expected = resolve20(input.roomRoot, "scratch");
+  if (resolve20(input.scratchPath) !== expected) {
     throw new Error(`refusing to remove scratch outside corner ${input.cornerId}`);
   }
-  await rm4(expected, { recursive: true, force: true });
+  await rm5(expected, { recursive: true, force: true });
 }
 var RoomRuntimeCoordinator = class {
   configPath;
@@ -23109,13 +23441,13 @@ var RoomRuntimeCoordinator = class {
     return this.runtime.rooms.find((room) => room.channelId === roomId);
   }
   roomRoot(roomId) {
-    return this.roomRecord(roomId)?.root ?? resolve19(dirname7(this.configPath), "rooms", roomId);
+    return this.roomRecord(roomId)?.root ?? resolve20(dirname8(this.configPath), "rooms", roomId);
   }
   roomAgentHomeRoot(workspaceRoot, required = false) {
     const flag = process.env.BUZZY_BODY_ROOM_HOME;
     if (!required && flag === "0")
       return void 0;
-    const home = resolve19(workspaceRoot, "agent-home");
+    const home = resolve20(workspaceRoot, "agent-home");
     if (!required && flag !== "1" && !existsSync4(home) && existsSync4(workspaceRoot))
       return void 0;
     try {
@@ -23131,10 +23463,10 @@ var RoomRuntimeCoordinator = class {
     return {
       ...this.baseConfig,
       workspaceRoot,
-      agentPrivateRoot: resolve19(workspaceRoot, "agent-private"),
-      agentMemoryRoot: resolve19(dirname7(this.configPath), "memory"),
-      openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname7(this.configPath)),
-      turnTraceDir: turnTraceDirectory(dirname7(this.configPath)),
+      agentPrivateRoot: resolve20(workspaceRoot, "agent-private"),
+      agentMemoryRoot: resolve20(dirname8(this.configPath), "memory"),
+      openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname8(this.configPath)),
+      turnTraceDir: turnTraceDirectory(dirname8(this.configPath)),
       ...agentHomeRoot ? { agentHomeRoot } : {}
     };
   }
@@ -23200,12 +23532,12 @@ var RoomRuntimeCoordinator = class {
       return this.roomRoot(roomId);
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
-    const checkoutId = createHash5("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
-    const path = resolve19(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
-    await mkdir12(dirname7(path), { recursive: true, mode: 448 });
+    const checkoutId = createHash6("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
+    const path = resolve20(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
+    await mkdir13(dirname8(path), { recursive: true, mode: 448 });
     const token = remote.startsWith("https://github.com/") ? await this.options.daemonApi.execute("getRoomGitHubToken", { roomId }) : void 0;
     const env = token ? githubGitEnv(token.token) : process.env;
-    if (!existsSync4(resolve19(path, ".git"))) {
+    if (!existsSync4(resolve20(path, ".git"))) {
       await execFileAsync4("git", ["clone", "--no-checkout", remote, path], {
         env,
         maxBuffer: 4 * 1024 * 1024
@@ -23258,9 +23590,9 @@ var RoomRuntimeCoordinator = class {
         featureBranch,
         token: granted.token
       }) : void 0;
-      const workspacePath = worktree?.path ?? resolve19(this.roomRoot(corner.cornerId), "scratch");
+      const workspacePath = worktree?.path ?? resolve20(this.roomRoot(corner.cornerId), "scratch");
       if (!worktree)
-        await mkdir12(workspacePath, { recursive: true, mode: 448 });
+        await mkdir13(workspacePath, { recursive: true, mode: 448 });
       const isOpener = !corner.openedBy || corner.openedBy === this.agent.publicKey;
       if (worktree && shouldPostInitialCornerWorkingState(restore, isOpener)) {
         await this.options.daemonApi.execute("postCornerRemoteState", {
@@ -23643,9 +23975,9 @@ var ThinDaemonCore = class {
 
 // apps/body/dist/systemd.js
 import { execFile as execFile6 } from "node:child_process";
-import { mkdir as mkdir13, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir14, readFile as readFile9, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, resolve as resolve20 } from "node:path";
+import { dirname as dirname9, resolve as resolve21 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile6);
@@ -23687,9 +24019,9 @@ WantedBy=default.target
 }
 function isCanonicalInstalledLauncher(env = process.env, invocationPath = process.argv[1]) {
   const home = env.HOME?.trim() || homedir8();
-  const expectedLibDir = resolve20(home, ".local", "lib", "beeline");
+  const expectedLibDir = resolve21(home, ".local", "lib", "beeline");
   const expectedPrefix = `${expectedLibDir}/`;
-  return resolve20(env.BEELINE_LIB_DIR?.trim() || "/") === expectedLibDir && Boolean(invocationPath) && resolve20(invocationPath).startsWith(expectedPrefix);
+  return resolve21(env.BEELINE_LIB_DIR?.trim() || "/") === expectedLibDir && Boolean(invocationPath) && resolve21(invocationPath).startsWith(expectedPrefix);
 }
 function assertCanonicalInstalledLauncher(env, invocationPath) {
   if (isCanonicalInstalledLauncher(env, invocationPath))
@@ -23697,8 +24029,8 @@ 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() || resolve20(homedir8(), ".config");
-  return resolve20(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve21(homedir8(), ".config");
+  return resolve21(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 var runSystemctl = async (args) => {
   const result = await execFileAsync5("systemctl", ["--user", ...args], {
@@ -23714,9 +24046,9 @@ async function installAgentService(publicKey, options = {}) {
   assertCanonicalInstalledLauncher(env, options.invocationPath);
   const path = systemdUserUnitPath(env);
   const content = agentServiceUnit();
-  const existing = await readFile8(path, "utf8").catch(() => "");
+  const existing = await readFile9(path, "utf8").catch(() => "");
   if (existing !== content) {
-    await mkdir13(dirname8(path), { recursive: true, mode: 448 });
+    await mkdir14(dirname9(path), { recursive: true, mode: 448 });
     await writeFile9(path, content, { mode: 384 });
   }
   const run2 = options.run ?? runSystemctl;
@@ -23797,7 +24129,7 @@ async function retireRemovedAgent(runtime, options = {}) {
 }
 
 // apps/body/dist/start-command.js
-import { dirname as dirname9 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 var import_picocolors = __toESM(require_picocolors(), 1);
 var DEFAULT_RESTART_DRAIN_TIMEOUT_MS = 30 * 6e4;
 var RESTART_WAIT_REPORT_INTERVAL_MS = 3e4;
@@ -23872,7 +24204,7 @@ async function runStartCommand(args, interactiveUi) {
       continue;
     }
     const spinnerHandle = spinner();
-    spinnerHandle.start(`Starting ${dirname9(path)}\u2026`);
+    spinnerHandle.start(`Starting ${dirname10(path)}\u2026`);
     try {
       await startRuntime(path, spinnerHandle);
       spinnerHandle.stop(import_picocolors.default.green("Started."));
@@ -23888,9 +24220,9 @@ async function runStartCommand(args, interactiveUi) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
-import { chmod as chmod5, mkdir as mkdir15, readFile as readFile10, unlink as unlink2, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve22 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { chmod as chmod6, mkdir as mkdir16, readFile as readFile11, unlink as unlink2, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname12, resolve as resolve23 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
 // apps/body/dist/clack-support.js
@@ -24157,7 +24489,11 @@ async function pairDevice(grant, options = {}) {
     ...grant.llmEnvFile ? { llmEnvFile: grant.llmEnvFile } : {},
     agent: selectedAgent
   });
-  await (options.validateSelection ?? validateAgentModelSelection)(selectedAgent, localConfig.agentEnv, { model: grant.model });
+  const modelSelection = {
+    model: grant.model,
+    ...grant.effort ? { effort: grant.effort } : {}
+  };
+  await (options.validateSelection ?? validateAgentModelSelection)(selectedAgent, localConfig.agentEnv, modelSelection);
   const agentIdentity = identityFromKey(grant.agentSecretKey, grant.agentName);
   const staged = await stageMonolithAgentRuntime({
     workspaceId: grant.workspaceId,
@@ -24169,7 +24505,7 @@ async function pairDevice(grant, options = {}) {
     agentKind: selectedAgent.kind,
     agentCommand: selectedAgent.command,
     agentArgs: selectedAgent.args,
-    modelSelection: { model: grant.model },
+    modelSelection,
     ...grant.accessPolicy ? { accessPolicy: grant.accessPolicy } : {},
     mcpBinary: localConfig.mcpBinary,
     agentIdentity,
@@ -24284,6 +24620,12 @@ var clackPrompts = {
     }), "Connection cancelled.");
   }
 };
+var CONNECT_EFFORT_CATEGORIES = ["effort", "reasoning_effort", "thought_level"];
+function connectEffortPickerFromAxes(axes, rawAxes = axes) {
+  const isEffort = (axis2) => CONNECT_EFFORT_CATEGORIES.includes(axis2.category) && axis2.options.length > 0;
+  const axis = axes.find(isEffort) ?? rawAxes.find(isEffort);
+  return axis ? { currentValue: axis.currentValue, options: axis.options } : void 0;
+}
 function connectModelPickerFromAxes(axes, fallbackModel, harness, rawAxes = axes) {
   const filtered = axes.find((axis) => axis.category === "model");
   if (filtered?.options.length) {
@@ -24301,13 +24643,18 @@ function connectModelPickerFromAxes(axes, fallbackModel, harness, rawAxes = axes
 }
 async function loadConnectModelCatalog(input) {
   const agent = resolveAgentCommand({ kind: input.harness });
+  const model = input.model ?? defaultConnectModel(input.harness, input.provider);
   const catalog = await fetchAgentModelCatalog(agent, providerEnvironment({
     harness: input.harness,
     ...input.provider ? { provider: input.provider } : {},
     ...input.apiKey ? { apiKey: input.apiKey } : {},
-    model: defaultConnectModel(input.harness, input.provider)
-  }), void 0, input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs });
-  return connectModelPickerFromAxes(catalog.catalog, defaultConnectModel(input.harness, input.provider), input.harness, catalog.raw);
+    model
+  }), input.model ? { model: input.model } : void 0, input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs });
+  const effort = connectEffortPickerFromAxes(catalog.catalog, catalog.raw);
+  return {
+    ...connectModelPickerFromAxes(catalog.catalog, defaultConnectModel(input.harness, input.provider), input.harness, catalog.raw),
+    ...effort ? { effort } : {}
+  };
 }
 var CONNECT_PROBE_TIMEOUT_MS = 12e3;
 function connectProbeFoundModels(catalog) {
@@ -24341,6 +24688,33 @@ 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({
+        harness: forHarness,
+        model: model2,
+        ...forProvider ? { provider: forProvider } : {},
+        ...forKey ? { apiKey: forKey } : {},
+        timeoutMs: CONNECT_PROBE_TIMEOUT_MS
+      }).catch(() => void 0);
+      axis = reread?.effort ?? axis;
+    }
+    if (!axis.options.length)
+      return void 0;
+    const picked = await prompts.select({
+      message: brass("Choose reasoning effort"),
+      options: axis.options.map((choice) => ({
+        value: choice.id,
+        label: choice.name ?? choice.id,
+        ...choice.id === axis.currentValue ? { hint: "current" } : {}
+      })),
+      ...axis.options.some((choice) => choice.id === axis.currentValue) ? { initialValue: axis.currentValue } : {}
+    });
+    return picked.trim();
+  };
   const probe = async (candidate) => {
     try {
       const catalog2 = await loadModels({
@@ -24373,10 +24747,9 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
       sole: harness === sole,
       ...configured.currentValue ? { model: configured.currentValue } : {}
     }));
-    return {
-      harness,
-      model: configured.currentValue ?? await askModel(configured, harness)
-    };
+    const model2 = await askModel(configured, harness);
+    const effort2 = await askEffort(configured, harness, model2);
+    return { harness, model: model2, ...effort2 ? { effort: effort2 } : {} };
   }
   let provider;
   let apiKey;
@@ -24435,11 +24808,13 @@ async function collectConnectWizard(prompts = clackPrompts, loadModels = loadCon
     ...apiKey ? { apiKey: apiKey.trim() } : {}
   });
   const model = await askModel(catalog, harness, provider);
+  const effort = await askEffort(catalog, harness, model, provider, apiKey?.trim());
   return {
     harness,
     ...provider ? { provider } : {},
     ...apiKey ? { apiKey: apiKey.trim() } : {},
-    model
+    model,
+    ...effort ? { effort } : {}
   };
 }
 async function jsonRequest(url, body, fetchImpl) {
@@ -24464,12 +24839,13 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
-  const avatarSeed = createHash7("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
+  const avatarSeed = createHash8("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,
+    ...selection.effort ? { effort: selection.effort } : {},
     avatar_seed: avatarSeed,
     // This wizard always finishes the join itself (`finishConnectedAgentPairing`,
     // called once the rename prompt below settles), so the claim must not
@@ -24511,7 +24887,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve22(layout.binDir, "beeline"),
+    binary: resolve23(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -24534,21 +24910,21 @@ function providerEnvironment(selection) {
   };
 }
 async function writePrivateJson(path, value) {
-  await mkdir15(dirname11(path), { recursive: true, mode: 448 });
+  await mkdir16(dirname12(path), { recursive: true, mode: 448 });
   await writeFile11(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  await chmod5(path, 384);
+  await chmod6(path, 384);
 }
 async function writeProviderEnv(selection, agentPubkey) {
   const values = providerEnvironment(selection);
   if (Object.keys(values).length === 0)
     return void 0;
-  const path = resolve22(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
-  await mkdir15(dirname11(path), { recursive: true, mode: 448 });
+  const path = resolve23(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
+  await mkdir16(dirname12(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
   await writeFile11(path, `${contents}
 `, { mode: 384 });
-  await chmod5(path, 384);
+  await chmod6(path, 384);
   return path;
 }
 async function runInstalledFinish(binary, grantPath) {
@@ -24609,13 +24985,16 @@ async function runConnectWizard(code, fetchImpl, eventSubscriptions, accessPolic
   await finishConnectedAgentPairing(baseUrl, pairingCode, grant.workspace_joined, eventSubscriptions, fetchImpl);
   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 = resolve22(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
+  const grantPath = resolve23(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
     agentName: grant.agent_name,
     harness: grant.harness,
     model: grant.model,
+    // The server echoes back what it stored; the wizard's own answer is the
+    // fallback for a server too old to carry the effort through.
+    ...grant.effort ?? selection.effort ? { effort: grant.effort ?? selection.effort } : {},
     soul: grant.soul,
     workspaceId: grant.workspace_id,
     workspaceName: grant.workspace_name,
@@ -24671,7 +25050,7 @@ function isDevicePairingGrant(value) {
   } catch {
     return false;
   }
-  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);
+  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" && (grant.effort === void 0 || typeof grant.effort === "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);
@@ -24691,18 +25070,18 @@ async function runConnectFinishCommand(path) {
     throw new Error("connect-finish may run only from the canonical installed Beeline launcher");
   }
   try {
-    const grant = JSON.parse(await readFile10(resolve22(path), "utf8"));
+    const grant = JSON.parse(await readFile11(resolve23(path), "utf8"));
     if (!isDevicePairingGrant(grant))
       throw new Error("device connection grant is invalid");
     const connected = await completeDevicePairing(grant);
-    await unlink2(resolve22(path));
-    const providerEnv = grant.llmEnvFile ? await readFile10(grant.llmEnvFile, "utf8").catch(() => "") : "";
+    await unlink2(resolve23(path));
+    const providerEnv = grant.llmEnvFile ? await readFile11(grant.llmEnvFile, "utf8").catch(() => "") : "";
     const apiKey = (/^OPENROUTER_API_KEY=(\S+)/m.exec(providerEnv)?.[1] ?? "").replace(/^["']|["']$/g, "");
     const model = openRouterModelId(grant.model, { OPENROUTER_API_KEY: apiKey });
     if (model) {
       const decision2 = await resolveOpenRouterRouting({
         model,
-        cacheDir: openRouterRoutingCacheDir(dirname11(connected.configPath)),
+        cacheDir: openRouterRoutingCacheDir(dirname12(connected.configPath)),
         ...apiKey ? { apiKey } : {},
         probeTimeoutMs: 1e4
       });
@@ -24724,24 +25103,24 @@ init_self_update_manifest();
 // apps/body/dist/managed-update.js
 init_self_update();
 import { spawn as spawn6 } from "node:child_process";
-import { mkdir as mkdir17, rm as rm6, stat as stat2, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname13, resolve as resolve24 } from "node:path";
+import { mkdir as mkdir18, rm as rm7, stat as stat3, writeFile as writeFile13 } from "node:fs/promises";
+import { dirname as dirname14, resolve as resolve25 } from "node:path";
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir16, readFile as readFile11, rename as rename4, unlink as unlink3, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname12, resolve as resolve23 } from "node:path";
+import { mkdir as mkdir17, readFile as readFile12, rename as rename5, unlink as unlink3, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname13, resolve as resolve24 } from "node:path";
 var REPORT_INTERVAL_MS = 60 * 60 * 1e3;
 var lastLogged = /* @__PURE__ */ new Map();
 function updateRollbackAlertPath(runtimeDir) {
-  return resolve23(runtimeDir, "update-rollback-alert.json");
+  return resolve24(runtimeDir, "update-rollback-alert.json");
 }
 async function writeAlert(runtimeDir, alert) {
   const path = updateRollbackAlertPath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir16(dirname12(path), { recursive: true });
+  await mkdir17(dirname13(path), { recursive: true });
   await writeFile12(staged, `${JSON.stringify(alert, null, 2)}
 `, { mode: 384 });
-  await rename4(staged, path);
+  await rename5(staged, path);
 }
 async function queueUpdateRollbackAlert(runtimeDir, releaseId, now2 = Date.now()) {
   const existing = await readUpdateRollbackAlert(runtimeDir);
@@ -24751,7 +25130,7 @@ async function queueUpdateRollbackAlert(runtimeDir, releaseId, now2 = Date.now()
 }
 async function readUpdateRollbackAlert(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile11(updateRollbackAlertPath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile12(updateRollbackAlertPath(runtimeDir), "utf8"));
     if (value.version !== 1 || typeof value.releaseId !== "string")
       return void 0;
     return value;
@@ -24802,22 +25181,22 @@ 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 = resolve24(layout.releasesRoot, ".state", "install.lock");
+  const lock = resolve25(layout.releasesRoot, ".state", "install.lock");
   const deadline = now2() + (options.waitMs ?? 1e4);
-  await mkdir17(dirname13(lock), { recursive: true });
+  await mkdir18(dirname14(lock), { recursive: true });
   for (; ; ) {
     try {
-      await mkdir17(lock);
-      await writeFile13(resolve24(lock, "owner"), `${process.pid}
+      await mkdir18(lock);
+      await writeFile13(resolve25(lock, "owner"), `${process.pid}
 ${now2()}
 `, "utf8");
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
-      const age = now2() - await stat2(lock).then((value) => value.mtimeMs).catch(() => now2());
+      const age = now2() - await stat3(lock).then((value) => value.mtimeMs).catch(() => now2());
       if (age > LOCK_STALE_MS) {
-        await rm6(lock, { recursive: true, force: true });
+        await rm7(lock, { recursive: true, force: true });
         continue;
       }
       if (now2() >= deadline)
@@ -24828,7 +25207,7 @@ ${now2()}
   try {
     return await work();
   } finally {
-    await rm6(lock, { recursive: true, force: true });
+    await rm7(lock, { recursive: true, force: true });
   }
 }
 var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
@@ -24931,7 +25310,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       if (!attempt || attempt.releaseId !== desiredRelease || attempt.status !== "pending") {
         const from = await readInstalledBundleIdentity({
           ...this.#layout,
-          libDir: resolve24(this.#layout.releasesRoot, this.#loadedRelease)
+          libDir: resolve25(this.#layout.releasesRoot, this.#loadedRelease)
         }).catch(() => void 0) ?? {};
         const to = await readInstalledBundleIdentity(this.#layout).catch(() => void 0) ?? {};
         const record2 = {
@@ -25218,7 +25597,7 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
   });
   if (!accepted)
     return false;
-  await writeFile13(resolve24(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
+  await writeFile13(resolve25(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
     readyAt: (options.now ?? Date.now)(),
     loadedRelease,
     functionalProof: options.functionalProof
@@ -25446,16 +25825,16 @@ async function runUpdateCommand(args) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir18, readFile as readFile12, rename as rename5, rm as rm7, writeFile as writeFile14 } from "node:fs/promises";
-import { dirname as dirname14, resolve as resolve25 } from "node:path";
+import { mkdir as mkdir19, readFile as readFile13, rename as rename6, rm as rm8, writeFile as writeFile14 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve26 } from "node:path";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
 function daemonFailurePath(runtimeDir) {
-  return resolve25(runtimeDir, "daemon-distress.json");
+  return resolve26(runtimeDir, "daemon-distress.json");
 }
 async function readFailureRecord(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile12(daemonFailurePath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile13(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;
     }
@@ -25467,10 +25846,10 @@ async function readFailureRecord(runtimeDir) {
 async function writeFailureRecord(runtimeDir, record2) {
   const path = daemonFailurePath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir18(dirname14(path), { recursive: true, mode: 448 });
+  await mkdir19(dirname15(path), { recursive: true, mode: 448 });
   await writeFile14(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
-  await rename5(staged, path);
+  await rename6(staged, path);
 }
 async function recordDaemonStartFailure(runtimeDir, error, now2 = Date.now()) {
   const prior = await readFailureRecord(runtimeDir);
@@ -25486,13 +25865,13 @@ async function recordDaemonStartFailure(runtimeDir, error, now2 = Date.now()) {
   return { distressed, count: failures.length, path: daemonFailurePath(runtimeDir) };
 }
 async function clearDaemonStartFailures(runtimeDir) {
-  await rm7(daemonFailurePath(runtimeDir), { force: true });
+  await rm8(daemonFailurePath(runtimeDir), { force: true });
 }
 
 // apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir19, rm as rm8 } from "node:fs/promises";
+import { mkdir as mkdir20, rm as rm9 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { resolve as resolve26 } from "node:path";
+import { resolve as resolve27 } 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;
@@ -25586,11 +25965,11 @@ async function runUpdateFunctionalProbe(input) {
       modelAnswerReason: `${detail} (the current release has the same host sandbox failure)`
     };
   }
-  const root = input.probeRoot ?? resolve26(input.runtimeDir, "update-functional-probe");
-  const cwd = resolve26(root, "checkout");
-  const homeRoot = resolve26(root, "agent-home");
-  await rm8(root, { recursive: true, force: true });
-  await mkdir19(cwd, { recursive: true, mode: 448 });
+  const root = input.probeRoot ?? resolve27(input.runtimeDir, "update-functional-probe");
+  const cwd = resolve27(root, "checkout");
+  const homeRoot = resolve27(root, "agent-home");
+  await rm9(root, { recursive: true, force: true });
+  await mkdir20(cwd, { recursive: true, mode: 448 });
   let client;
   try {
     const agentEnv = {
@@ -25620,7 +25999,7 @@ async function runUpdateFunctionalProbe(input) {
       const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
       const operatorHome = input.config.operatorHome ?? homedir10();
       const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-      await Promise.all(homeStateDirs.map((dir) => mkdir19(dir, { recursive: true })));
+      await Promise.all(homeStateDirs.map((dir) => mkdir20(dir, { recursive: true })));
       spawnCommand = wrapAgentCommand({
         bwrapPath: input.config.bwrapPath,
         spec: {
@@ -25764,13 +26143,13 @@ async function runUpdateFunctionalProbe(input) {
     };
   } finally {
     await client?.stop().catch(() => void 0);
-    await rm8(root, { recursive: true, force: true }).catch(() => void 0);
+    await rm9(root, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 
 // apps/body/dist/current-release-probe.js
 import { spawn as spawn7 } from "node:child_process";
-import { dirname as dirname15, join as join9 } from "node:path";
+import { dirname as dirname16, join as join10 } from "node:path";
 init_self_update();
 var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 12e4;
 var UPDATE_PROBE_COMMAND = "update-probe";
@@ -25813,13 +26192,13 @@ function outcomeFromReport(report) {
   }
 }
 async function probeReleaseInSubprocess(input) {
-  const bundleDir = join9(input.layout.releasesRoot, input.releaseId);
+  const bundleDir = join10(input.layout.releasesRoot, input.releaseId);
   const entrypoint = await resolveBundleEntrypoint(bundleDir);
   if (!entrypoint) {
     return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
   }
   const timeoutMs = input.timeoutMs ?? CURRENT_RELEASE_PROBE_TIMEOUT_MS;
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const child = spawn7(input.execPath ?? process.execPath, [entrypoint, UPDATE_PROBE_COMMAND, "--config", input.runtimeConfigPath], { env: input.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout6 = "";
     let stderr = "";
@@ -25829,7 +26208,7 @@ async function probeReleaseInSubprocess(input) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve30(outcome);
+      resolve31(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -25876,7 +26255,7 @@ async function runUpdateProbeCommand(args, options = {}) {
   const runtime = await readRuntimeRecord(configPath);
   const agent = runtimeAgentCommand(runtime);
   const config = loadBodyConfig({
-    workspaceRoot: join9(dirname15(configPath), "workspace"),
+    workspaceRoot: join10(dirname16(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env: { ...env, BUZZ_AGENT_BIN: agent.command, BUZZ_DEV_MCP_BIN: runtime.mcpBinary },
     agent
@@ -25894,7 +26273,7 @@ async function runUpdateProbeCommand(args, options = {}) {
   }
   const layout = beelineInstallLayout(env);
   const releaseId = (layout && await activeReleaseId(layout).catch(() => void 0)) ?? "unknown";
-  const runtimeDir = dirname15(configPath);
+  const runtimeDir = dirname16(configPath);
   const outcome = await probeOutcome(() => (options.probe ?? runUpdateFunctionalProbe)({
     config,
     runtimeDir,
@@ -25902,15 +26281,15 @@ async function runUpdateProbeCommand(args, options = {}) {
     sandboxRequired: runtime.sandbox !== "off",
     sandboxUnavailableDetail: sandbox.advisory,
     // The successor's probe still holds `<runtimeDir>/update-functional-probe`.
-    probeRoot: join9(runtimeDir, "current-release-probe")
+    probeRoot: join10(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));
 }
 
 // apps/body/dist/release-status.js
-import { readFile as readFile13, readdir as readdir5, rename as rename6, writeFile as writeFile15 } from "node:fs/promises";
-import { resolve as resolve27 } from "node:path";
+import { readFile as readFile14, readdir as readdir6, rename as rename7, writeFile as writeFile15 } from "node:fs/promises";
+import { resolve as resolve28 } 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}$/;
@@ -25927,17 +26306,17 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
     pid: options.pid ?? process.pid,
     readyAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
   };
-  const target = resolve27(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
+  const target = resolve28(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
   const temporary = `${target}.${status.pid}.tmp`;
   await writeFile15(temporary, `${JSON.stringify(status, null, 2)}
 `, { mode: 384 });
-  await rename6(temporary, target);
+  await rename7(temporary, target);
   return status;
 }
 
 // apps/body/dist/scratch-sweep.js
-import { lstat as lstat3, readdir as readdir6, rmdir, unlink as unlink4 } from "node:fs/promises";
-import { resolve as resolve28 } from "node:path";
+import { lstat as lstat4, readdir as readdir7, rmdir, unlink as unlink4 } from "node:fs/promises";
+import { resolve as resolve29 } from "node:path";
 var DEFAULT_SCRATCH_TTL_HOURS = 72;
 var NEVER_SWEEP_SUBDIR_NAMES = new Set(HOME_SUBDIRS.filter((name) => name !== "tmp"));
 function scratchTtlMs(env = process.env) {
@@ -25946,10 +26325,10 @@ function scratchTtlMs(env = process.env) {
   return (Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_SCRATCH_TTL_HOURS) * 60 * 60 * 1e3;
 }
 async function discoverAttachScratchRoots(runtimeDir) {
-  const roomsDir = resolve28(runtimeDir, "rooms");
+  const roomsDir = resolve29(runtimeDir, "rooms");
   let entries;
   try {
-    entries = await readdir6(roomsDir, { withFileTypes: true });
+    entries = await readdir7(roomsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -25957,8 +26336,8 @@ async function discoverAttachScratchRoots(runtimeDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const home = resolve28(roomsDir, entry.name, "agent-home");
-    const stats = await lstat3(home).catch(() => void 0);
+    const home = resolve29(roomsDir, entry.name, "agent-home");
+    const stats = await lstat4(home).catch(() => void 0);
     if (stats?.isDirectory())
       roots.push(home);
   }
@@ -25967,7 +26346,7 @@ async function discoverAttachScratchRoots(runtimeDir) {
 async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
   let entries;
   try {
-    entries = await readdir6(dir, { withFileTypes: true });
+    entries = await readdir7(dir, { withFileTypes: true });
   } catch {
     return { removedFiles: 0, removedBytes: 0 };
   }
@@ -25976,15 +26355,15 @@ async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
   for (const entry of entries) {
     if (protectNamesHere && NEVER_SWEEP_SUBDIR_NAMES.has(entry.name))
       continue;
-    const path = resolve28(dir, entry.name);
-    const stats = await lstat3(path).catch(() => void 0);
+    const path = resolve29(dir, entry.name);
+    const stats = await lstat4(path).catch(() => void 0);
     if (!stats || stats.isSymbolicLink())
       continue;
     if (stats.isDirectory()) {
       const nested = await removeStaleFiles(path, cutoffMs, false);
       removedFiles += nested.removedFiles;
       removedBytes += nested.removedBytes;
-      const remaining = await readdir6(path).catch(() => void 0);
+      const remaining = await readdir7(path).catch(() => void 0);
       if (remaining && remaining.length === 0)
         await rmdir(path).catch(() => void 0);
       continue;
@@ -26002,7 +26381,7 @@ async function sweepAttachScratchRoots(roots, ttlMs, now2 = Date.now()) {
   let removedFiles = 0;
   let removedBytes = 0;
   for (const root of roots) {
-    const stats = await lstat3(root).catch(() => void 0);
+    const stats = await lstat4(root).catch(() => void 0);
     if (!stats?.isDirectory())
       continue;
     const result = await removeStaleFiles(root, cutoffMs, true);
@@ -26063,7 +26442,7 @@ var DaemonExitError = class extends Error {
 };
 async function runStoredDaemon(pathOrPointer) {
   const configPath = await resolveRuntimeConfigPath(pathOrPointer);
-  daemonFailureRuntimeDir = dirname16(configPath);
+  daemonFailureRuntimeDir = dirname17(configPath);
   const accessMigration = await migrateRuntimeRecordAccessPolicy(configPath);
   let runtime = accessMigration.runtime;
   if (!runtime.transport) {
@@ -26075,7 +26454,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile16(resolve29(dirname16(configPath), "daemon.pid"), `${process.pid}
+  await writeFile16(resolve30(dirname17(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -26083,7 +26462,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve29(dirname16(configPath), "workspace"),
+    workspaceRoot: resolve30(dirname17(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -26118,7 +26497,7 @@ async function runStoredDaemon(pathOrPointer) {
   const stop = () => controller.abort();
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
-  const runtimeDir = dirname16(configPath);
+  const runtimeDir = dirname17(configPath);
   const layout = beelineInstallLayout(process.env);
   const notifier = new SystemdNotifier();
   let rollbackAlertDrain;
@@ -26265,8 +26644,8 @@ async function runStoredDaemon(pathOrPointer) {
   } finally {
     clearInterval(scratchSweepTimer);
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve29(dirname16(configPath), "daemon.pid");
-    const recorded = Number((await readFile14(pidPath, "utf8").catch(() => "")).trim());
+    const pidPath = resolve30(dirname17(configPath), "daemon.pid");
+    const recorded = Number((await readFile15(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
       await unlink5(pidPath).catch(() => void 0);
     }
@@ -26293,7 +26672,7 @@ async function main() {
     const roomId = roomFlag >= 0 ? args[roomFlag + 1] : void 0;
     if (!configPath || !roomId)
       throw new Error("corner-read-token requires --config and --room");
-    const activated = await activateDaemonTransport(resolve29(configPath));
+    const activated = await activateDaemonTransport(resolve30(configPath));
     if (!activated)
       throw new Error("corner-read-token requires monolith transport");
     const credential = await activated.client.execute("getRoomGitHubToken", { roomId });
@@ -26342,14 +26721,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) => dirname16(candidate).endsWith(agentPubkey));
+      configPath = configs.find((candidate) => dirname17(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(resolve29(configPath));
+    await runStoredDaemon(resolve30(configPath));
     return;
   }
   if (command === "update") {
@@ -26370,7 +26749,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) => dirname16(candidate).endsWith(agentPubkey));
+    const configPath = configs.find((candidate) => dirname17(candidate).endsWith(agentPubkey));
     if (!configPath)
       throw new Error(`no stored runtime found for agent ${agentPubkey}`);
     const runtime = await readRuntimeRecord(configPath);