usebeeline 0.0.91 → 0.0.94

package/dist/usebeeline.mjs

@@ -2413,9 +2413,9 @@ var require_websocket = __commonJS({
     var EventEmitter2 = __require("events");
     var https = __require("https");
     var http = __require("http");
-    var net = __require("net");
+    var net2 = __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;
@@ -3157,12 +3157,12 @@ var require_websocket = __commonJS({
     }
     function netConnect(options) {
       options.path = options.socketPath;
-      return net.connect(options);
+      return net2.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net.isIP(options.host) ? "" : options.host;
+        options.servername = net2.isIP(options.host) ? "" : options.host;
       }
       return tls.connect(options);
     }
@@ -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);
@@ -4654,9 +4654,22 @@ var init_self_update = __esm({
   }
 });
 
+// apps/body/dist/network-family-bootstrap.js
+import * as net from "node:net";
+var NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 5e3;
+function configureNetworkFamilyDefaults(network = net) {
+  if (typeof network.setDefaultAutoSelectFamilyAttemptTimeout === "function") {
+    network.setDefaultAutoSelectFamilyAttemptTimeout(NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS);
+    return "timeout";
+  }
+  network.setDefaultAutoSelectFamily?.(false);
+  return "autoselection-disabled";
+}
+configureNetworkFamilyDefaults();
+
 // 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 +7540,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 +7548,7 @@ var AcpClient = class extends EventEmitter {
         if (!runId)
           return;
         cleanup();
-        resolve30(runId);
+        resolve31(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -7619,13 +7632,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,
@@ -8010,7 +8023,24 @@ async function withAgentModelCatalog(agent, agentEnv, selection, inspect, limits
   }
 }
 async function fetchAgentModelCatalog(agent, agentEnv, selection, limits = {}) {
-  return withAgentModelCatalog(agent, agentEnv, selection, async ({ raw, catalog }) => ({ raw, catalog }), limits);
+  return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => ({
+    raw,
+    catalog: await filterModelChoicesByLiveValidation(client, sessionId, catalog)
+  }), limits);
+}
+async function filterModelChoicesByLiveValidation(client, sessionId, catalog) {
+  const modelAxis = catalog.find((axis) => axis.category === "model");
+  if (!modelAxis)
+    return catalog;
+  const available = [];
+  for (const choice of modelAxis.options) {
+    try {
+      await applyAgentModelSelection(client, sessionId, catalog, { model: choice.id });
+      available.push(choice);
+    } catch {
+    }
+  }
+  return catalog.map((axis) => axis === modelAxis ? { ...axis, options: available } : axis);
 }
 async function validateAgentModelSelection(agent, agentEnv, selection) {
   return withAgentModelCatalog(agent, agentEnv, selection, async ({ client, sessionId, raw, catalog }) => {
@@ -8066,8 +8096,12 @@ import { readFile, writeFile } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 var MODEL_CATALOG_PROBE_TIMEOUT_MS = 3e4;
 var MODEL_CATALOG_HASH_FILE = "model-catalog.sha256";
-function modelCatalogHash(options, selection) {
-  return createHash("sha256").update(JSON.stringify({ options, selection: selection ?? null })).digest("hex");
+function modelCatalogHash(options, selection, startupUnavailable) {
+  return createHash("sha256").update(JSON.stringify({
+    options,
+    selection: selection ?? null,
+    startupUnavailable: startupUnavailable ?? null
+  })).digest("hex");
 }
 async function withTimeout(work, timeoutMs, what) {
   let timer;
@@ -8093,8 +8127,8 @@ async function syncAgentModelCatalog(input) {
       ...configuration.model ? { model: configuration.model } : {},
       ...configuration.effort ? { effort: configuration.effort } : {}
     } : input.runtimeSelection;
-    const { catalog } = await withTimeout(fetchCatalog(input.agent, input.agentEnv, selection), input.timeoutMs ?? MODEL_CATALOG_PROBE_TIMEOUT_MS, "model catalog probe");
-    const hash = modelCatalogHash(catalog, selection);
+    const { catalog } = await withTimeout(fetchCatalog(input.agent, input.agentEnv, input.startupUnavailable ? void 0 : selection), input.timeoutMs ?? MODEL_CATALOG_PROBE_TIMEOUT_MS, "model catalog probe");
+    const hash = modelCatalogHash(catalog, selection, input.startupUnavailable);
     const previous = await readFile(hashPath, "utf8").catch(() => "");
     if (previous.trim() === hash)
       return "unchanged";
@@ -8103,7 +8137,8 @@ async function syncAgentModelCatalog(input) {
       workspaceId: input.workspaceId,
       // `fetchAgentModelCatalog` already applied the category allow-list.
       options: catalog,
-      ...selection ? { selection } : {}
+      ...selection ? { selection } : {},
+      ...input.startupUnavailable ? { unavailable: input.startupUnavailable } : {}
     });
     await writeFile(hashPath, `${hash}
 `, { mode: 384 });
@@ -17164,10 +17199,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 +17484,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 +17503,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 +18172,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 +18204,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
@@ -18201,6 +18236,7 @@ function isAgentPairingCode(value) {
 
 // apps/body/dist/beeline-skill.js
 var USING_BEELINE_SKILL_NAME = "using-beeline";
+var BEELINE_REVIEW_SKILL_NAME = "beeline-review";
 var BEELINE_ROOM_CAPABILITIES = [
   "The repository filesystem is read-only in this Room session.",
   "You may address any Room member, including another agent, by writing @name in your reply; the server routes that mention to them. Each turn prompt lists the Room members and the exact spelling that tags each one - use those spellings, and never guess or reuse one from an older message.",
@@ -18265,6 +18301,86 @@ description: How to answer inside a Beeline Room.
 You are answering inside a Room whose filesystem is read-only. ${BEELINE_ROOM_CAPABILITIES}
 `;
 }
+function beelineReviewSkillMarkdown(releaseId) {
+  return `---
+name: beeline-review
+description: Review a corner pull request against its objective and the Beeline merge gate.
+---
+
+<!-- beeline-release: ${releaseId} -->
+
+# Beeline pull-request review
+
+Follow these steps in order. Do not skip or reorder them.
+
+## 1. Isolate the revision
+
+- Run \`gh pr view N --json headRefOid,files\` and record \`headRefOid\`.
+- Run \`gh pr diff N\`.
+- Check out that exact head in a new scratch git worktree. Never use the author's worktree.
+- Review and test only the recorded revision. If the head moves, start over.
+
+## 2. P0 - OBJECTIVE FULFILLED, DEMONSTRATED
+
+- Quote the corner objective verbatim.
+- Derive its end-user story in one sentence: \`a user who does X sees Y\`.
+- Make Y happen against the built PR head: run the app or affected service and perform X.
+- If no interactive surface is reachable, run the narrowest test or script that exercises the exact user path and prints the observable Y.
+- Record the command and the observed Y.
+- A unit test of an inner function, a log line, \`the code looks right\`, or any other proxy does not count.
+- If the user-visible Y cannot be produced, FAIL now. Nothing below can rescue the review.
+- State whether the diff fulfills that objective and only that objective.
+
+## 3. Empirical pass second
+
+- Run the repository typecheck and tests touched by the diff.
+- If the objective names a user path, exercise that path.
+- Record every command and exit code.
+- A review with no executed command is invalid and must FAIL.
+
+## 4. Adversarial pass
+
+- For every changed function, name one concrete input or sequence that breaks it.
+- If none is found, write \`none found\` for that function.
+
+## 5. Verify before reporting
+
+- Confirm every finding by reading the exact line or by running a command.
+- Put unconfirmed concerns under plausible findings. They never block.
+
+## 6. Bloat guard
+
+- Compare net lines with the objective.
+- FAIL backwards-compatibility shims, dual paths, feature flags, or abstractions with one caller.
+- FAIL machinery the objective did not ask for.
+
+## 7. Security and data
+
+- Check credentials, authorization boundaries, and destructive migrations.
+
+## 8. Gate and verdict
+
+- The merge gate is open only when \`pr_checks_status\` reports checks=passed, held=false, approvalPending=false.
+- Green \`gh pr checks\` alone never opens the gate.
+- Always use this exact verdict shape:
+
+\`objective quoted:\`
+\`user story:\`
+\`how Y was demonstrated (or FAIL):\`
+\`commands run + results:\`
+\`critical findings (block):\`
+\`plausible findings (do not block):\`
+\`net lines:\`
+\`decision: PASS|FAIL\`
+
+Then take exactly one action:
+
+- FAIL: reply \`@author\` with the confirmed findings; do not merge.
+- PASS with pending checks: reply \`approved pending checks <reviewed sha>\` and stop.
+- PASS with the gate open and your yolo on: run \`gh pr merge --squash --match-head-commit <reviewed sha> N\`.
+- PASS with the gate open and your yolo off: reply \`approved <reviewed sha>\` and stop.
+`;
+}
 
 // apps/body/dist/external-mcp-capabilities.js
 var SQUIRE_MCP_VERSION = "1.1.12";
@@ -18862,7 +18978,10 @@ var SHARED_CREDENTIALS = [
   { dir: "pi", source: ".pi/agent/auth.json", target: "auth.json" }
 ];
 var GOOSE_SHARED_CONFIG_FILES = ["config.yaml", "secrets.yaml"];
-var BEELINE_DEFAULT_SKILL_NAMES = [USING_BEELINE_SKILL_NAME];
+var BEELINE_DEFAULT_SKILL_NAMES = [
+  BEELINE_REVIEW_SKILL_NAME,
+  USING_BEELINE_SKILL_NAME
+];
 var OPERATOR_SKILL_SOURCE_DIRS = [
   ".agents/skills",
   ".claude/skills",
@@ -18941,7 +19060,8 @@ async function prepareRoomAgentHome(input) {
 }
 async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting) {
   const managedSkills = [
-    { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) }
+    { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) },
+    { name: BEELINE_REVIEW_SKILL_NAME, content: beelineReviewSkillMarkdown(skillReleaseId) }
   ];
   const shared = await resolveSharedSkillSources(operatorHome, sharedSkills);
   await provisionManagedSkillsDir(resolve13(root, skillDir, "skills"), managedSkills, shared, sharedSkills.length === 0);
@@ -18995,7 +19115,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 +19679,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"],
@@ -19629,6 +19737,12 @@ var AgentTurnStream = class {
   inFlight;
   /** Closed lanes publish nothing more, so the answer never queues behind a draft. */
   closed = false;
+  /**
+   * The retract this lane already sent. A settled turn that throws afterwards
+   * reaches the same retract a second time, and one empty lane is the whole
+   * point: asking twice would only be a second write saying what is already so.
+   */
+  retraction;
   constructor(options) {
     this.options = options;
   }
@@ -19688,14 +19802,45 @@ var AgentTurnStream = class {
     this.closed = true;
     this.pending = void 0;
   }
+  /**
+   * Dissolve the draft, publishing nothing.
+   *
+   * Every ending uses this: the settle below calls it once the durable reply is
+   * on the wire, and a turn that THROWS calls it directly. A throw never
+   * reaches a settle, and `close()` alone only stops future writes — the last
+   * snapshot stays live on the page, so a turn the Room has already reported
+   * stopped or failed keeps a half-written answer visibly in progress under it.
+   */
+  async retract() {
+    this.close();
+    this.retraction ??= (async () => {
+      await this.inFlight;
+      const { api, agentId, roomId, requestId, label } = this.options;
+      await api.execute("retractAgentLiveOutput", {
+        agentId,
+        roomId,
+        turnId: requestId,
+        kind: "draft"
+      }).catch((error) => console.error(`[thin-core] ${label} draft retract failed:`, error));
+    })();
+    await this.retraction;
+  }
   /**
    * Post the durable reply under the turn's request id and dissolve the draft.
    * An empty reply settles through the turn receipt instead, and the lane is
    * retracted either way.
+   *
+   * The durable reply is this turn's answer and its last word. The draft lane
+   * is presentation, so a refused retract is logged like a refused draft and
+   * the turn still settles complete: raising here failed a turn that had
+   * already answered, which posts a `failed` receipt and inscribes "<agent>
+   * could not answer" UNDER the answer the reader is looking at. The reader
+   * loses nothing by it either — the phone ends a retracted draft on the
+   * turn's own complete receipt (`visibleLiveOverlays`).
    */
   async settle(reply, fields = {}, onReplyPosted) {
     this.close();
-    const { api, agentId, roomId, requestId } = this.options;
+    const { api, roomId, requestId } = this.options;
     if (reply) {
       const posted = await api.execute("postRoomMessage", {
         roomId,
@@ -19706,13 +19851,7 @@ var AgentTurnStream = class {
       });
       onReplyPosted?.(posted);
     }
-    await this.inFlight;
-    await api.execute("retractAgentLiveOutput", {
-      agentId,
-      roomId,
-      turnId: requestId,
-      kind: "draft"
-    });
+    await this.retract();
   }
 };
 
@@ -19722,13 +19861,18 @@ function redactToolDetail(value) {
   return value.replace(/\b(["']?)(api[_-]?key|token|secret|password|passwd|authorization|credential|cookie|private[_-]?key)\1\s*[:=]\s*(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,}\]]+)/gi, '"$2": "[REDACTED]"').replace(/\b(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*=(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\S+)/g, (assignment) => `${assignment.slice(0, assignment.indexOf("="))}=[REDACTED]`).replace(/\b(?:gh[pousr]_[A-Za-z0-9_]{12,}|github_pat_[A-Za-z0-9_]{12,})\b/gi, "[REDACTED]").replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(/\b(Bearer\s+)[^\s,]+/gi, "$1[REDACTED]").replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "[REDACTED]").replace(/(--?(?:api[_-]?key|token|secret|password|authorization|credential|cookie)\s+)(?:"[^"]*"|'[^']*'|\S+)/gi, "$1[REDACTED]");
 }
 function distillTurnFailureReason(error) {
+  if (error instanceof ModelSelectionUnavailableError) {
+    return { text: "model selection unavailable", kind: "model-selection-unavailable" };
+  }
   const raw = error instanceof Error ? error.message : typeof error === "string" ? error : error && typeof error === "object" && "message" in error ? String(error.message) : error == null ? "" : String(error);
   const firstLine = raw.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !/^at\s/.test(line)) ?? "";
   const stripped = firstLine.replace(/^(?:[A-Za-z]*Error|Error):\s*/, "").replace(/\s+/g, " ");
   const clean4 = redactToolDetail(stripped).trim();
   if (!clean4)
-    return "turn failed";
-  return clean4.length > TURN_FAILURE_REASON_MAX ? `${clean4.slice(0, TURN_FAILURE_REASON_MAX - 1)}\u2026` : clean4;
+    return { text: "turn failed" };
+  return {
+    text: clean4.length > TURN_FAILURE_REASON_MAX ? `${clean4.slice(0, TURN_FAILURE_REASON_MAX - 1)}\u2026` : clean4
+  };
 }
 
 // apps/body/dist/tool-call-failure.js
@@ -19762,6 +19906,9 @@ function toolCallText(content) {
 function isFailedToolCall(call) {
   return /^(?:failed|error|denied|rejected)$/i.test(call.status ?? "");
 }
+function isCompletedToolCall(call) {
+  return /^completed$/i.test(call.status ?? "");
+}
 function toolCallFailureLine(call) {
   if (!isFailedToolCall(call))
     return void 0;
@@ -19772,14 +19919,17 @@ function toolCallFailureLine(call) {
 
 // apps/body/dist/session-config-fingerprint.js
 function sessionConfigFingerprint(input) {
-  return JSON.stringify([
+  const fingerprint = [
     input.model ?? "",
     input.effort ?? "",
     input.soul?.name ?? "",
     input.soul?.instructions ?? "",
     input.agentName ?? "",
     input.yoloMode ?? false
-  ]);
+  ];
+  if (input.reviewerHandle !== void 0)
+    fingerprint.push(input.reviewerHandle);
+  return JSON.stringify(fingerprint);
 }
 
 // apps/body/dist/pi-mcp-bridge.js
@@ -20792,16 +20942,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;
@@ -20997,7 +21430,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;
   }
@@ -21064,7 +21497,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,
@@ -21090,14 +21523,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: {
@@ -21287,6 +21720,7 @@ var MonolithRoomTurnLoop = class {
     const api = this.options.api;
     this.busy = true;
     const trace = this.beginTurnTrace(item.id);
+    let liveStream;
     try {
       if (!this.memberNames.has(item.authorId))
         await this.roster().catch(() => void 0);
@@ -21353,6 +21787,7 @@ var MonolithRoomTurnLoop = class {
             requestId: item.id,
             label: `monolith Room ${this.options.roomId}`
           });
+          liveStream = stream;
           const runPrompt = async () => {
             let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
             let result2;
@@ -21361,7 +21796,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));
@@ -21390,7 +21825,9 @@ var MonolithRoomTurnLoop = class {
           };
           let result = await runPrompt();
           trace.promptSettled();
-          let explained = await this.explainEmpty(result);
+          let openCornerCall = openCornerToolCall(result.toolCalls);
+          let cornerOpened = openedACorner(openCornerCall);
+          let explained = cornerOpened ? void 0 : await this.explainEmpty(result);
           if (explained && shouldRetryEmptyTurn(explained)) {
             const silent = this.servingProviders();
             const next = await this.repinNextProvider(trace, explained.reason);
@@ -21398,7 +21835,9 @@ var MonolithRoomTurnLoop = class {
               console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
               result = await runPrompt();
               trace.promptSettled();
-              explained = await this.explainEmpty(result);
+              openCornerCall = openCornerToolCall(result.toolCalls);
+              cornerOpened = openedACorner(openCornerCall);
+              explained = cornerOpened ? void 0 : await this.explainEmpty(result);
             }
           }
           if (active.cancelled) {
@@ -21412,10 +21851,9 @@ var MonolithRoomTurnLoop = class {
           } else if (resumedRequestId) {
             console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${resumedRequestId} resumed by grant decision ${item.id}`);
           }
-          const openCornerCall = result.toolCalls.find((call) => /(?:^|[._:/-])open_corner$/i.test(call.title ?? ""));
           if (openCornerCall) {
             console.log(`[thin-core] monolith Room ${this.options.roomId} tool call: ${openCornerCall.title} (${openCornerCall.status ?? "no status"})`);
-            if (!isFailedToolCall(openCornerCall))
+            if (cornerOpened)
               this.options.onCornerOpened?.();
           }
           for (const call of result?.toolCalls ?? []) {
@@ -21433,8 +21871,8 @@ var MonolithRoomTurnLoop = class {
             }
             console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
           }
-          if (openCornerCall && !isFailedToolCall(openCornerCall)) {
-            reply = stripCornerOpenEcho(reply);
+          if (cornerOpened) {
+            reply = "";
           }
           await trace.measure("publish", () => stream.settle(reply, reply ? {
             triggerMessageId: item.id
@@ -21455,6 +21893,9 @@ var MonolithRoomTurnLoop = class {
         await trace.finish("cancelled");
         return;
       }
+      await liveStream?.retract().catch((retractError) => {
+        console.error(`[thin-core] monolith Room ${this.options.roomId} draft retract failed:`, retractError);
+      });
       const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
@@ -21462,9 +21903,10 @@ var MonolithRoomTurnLoop = class {
         requestId: item.id,
         status: "failed",
         generationId: this.commandContext.generationId,
-        reason
+        reason: reason.text,
+        ...reason.kind ? { reasonKind: reason.kind } : {}
       });
-      await trace.finish("failed", reason);
+      await trace.finish("failed", reason.text);
       throw error;
     } finally {
       this.busy = false;
@@ -21507,6 +21949,12 @@ var MonolithRoomTurnLoop = class {
     }
   }
 };
+function openCornerToolCall(calls) {
+  return calls.find((call) => /(?:^|[._:/-])open_corner$/i.test(call.title ?? ""));
+}
+function openedACorner(call) {
+  return !!call && isCompletedToolCall(call);
+}
 function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsImages = true) {
   const message = body.trim() || "(shared attachments)";
   const rendered = author ? `${author}: ${message}` : message;
@@ -21518,9 +21966,65 @@ var execFileAsync3 = promisify3(execFile4);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
-function cornerMergeInstruction(yoloMode) {
+function cornerMergeInstruction(yoloMode, reviewerHandle) {
+  if (reviewerHandle)
+    return `Commit, push, open the pull request, reply with the PR URL and then @${reviewerHandle} please review; never merge this PR yourself. If you asked any other agent to review in this corner, do not merge until they answer.`;
   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.";
 }
+function cornerReviewerInstruction(input) {
+  if (!input.reviewerHandle || !input.agentHandle || input.openedByAgent || input.agentHandle.replace(/^@/, "") !== input.reviewerHandle.replace(/^@/, ""))
+    return void 0;
+  const author = input.authorHandle?.replace(/^@/, "") || "author";
+  const number = input.pullRequestNumber ?? "N";
+  return `Review PR #${number} with the beeline-review skill. If it fails, reply @${author} with the findings. If it passes and the gate (pr_checks_status: checks=passed, held=false, approvalPending=false) is open and YOUR yolo is on, merge with gh pr merge --squash --match-head-commit <sha you reviewed>; if your yolo is off, reply approved <sha> and stop; if checks are pending, reply approved pending checks <sha> and stop.`;
+}
+var CORNER_AUTHOR_CONTRACT = `The objective text is the user's ask. Keep it verbatim in your head and do not reinterpret it.
+Before any code, write its end-user story in one sentence: "a person who does X sees Y".
+If the objective reports a defect, reproduce it first at the layer where it lives: the command, request, or tap sequence, and what was observed.
+Do not write a fix before you have seen the defect. Turn the reproduction into the regression test.
+Before opening the pull request, produce Y against the built change: run the app or affected service from your branch and perform X.
+If no interactive surface is reachable, run the narrowest test or script that exercises the exact user path and prints the observable Y.
+A unit test of an inner function, a log line, or reading the code is not a demonstration.
+The pull request body MUST contain two sections with exactly these headings: ## Reproduced and ## Demonstrated.
+Under ## Reproduced, give the steps or command and what was observed; write "not a defect report" for feature work.
+Under ## Demonstrated, give the command or steps that produced Y and what was observed.
+A pull request without both sections is not deliverable and the Room's reviewer will fail it.
+Change only what the objective asks. No unrequested features, flags, compatibility shims, or refactors.`;
+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. The pull request body must carry ## Reproduced and ## Demonstrated; if they are missing, add them before ending the turn.";
+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();
 }
@@ -21606,7 +22110,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)
@@ -21669,6 +22173,14 @@ 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;
+  /** The live parent-Room reviewer baked into the current session. */
+  reviewerHandle;
+  /** The role-specific second-chance instruction for this session. */
+  cornerTurnEndNudge = CORNER_DELIVERY_NUDGE;
+  /** Repository state already given a delivery reminder, until that state changes. */
+  lastDeliveryNudgeState;
   turnIdentityInstructions = "";
   busy = false;
   forcedStop = false;
@@ -21693,6 +22205,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);
@@ -21782,7 +22296,8 @@ var MonolithCornerTurnLoop = class {
       effort: configuration.effort ?? this.options.config.modelSelection?.effort,
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name,
-      yoloMode: configuration.yoloMode
+      yoloMode: configuration.yoloMode,
+      reviewerHandle: configuration.reviewerHandle
     });
   }
   async activate(trace) {
@@ -21802,9 +22317,31 @@ var MonolithCornerTurnLoop = class {
       effort: configuration.effort ?? this.options.config.modelSelection?.effort,
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name,
-      yoloMode: configuration.yoloMode
+      yoloMode: configuration.yoloMode,
+      reviewerHandle: configuration.reviewerHandle
     });
-    await mkdir11(this.options.worktreePath, { recursive: true });
+    this.yoloMode = configuration.yoloMode;
+    this.reviewerHandle = configuration.reviewerHandle;
+    const opener = this.options.openedBy ? roster.members.find((member) => member.identityId === this.options.openedBy) : void 0;
+    const reviewerInput = {
+      reviewerHandle: configuration.reviewerHandle,
+      agentHandle: self?.handle,
+      authorHandle: opener?.handle,
+      openedByAgent: !this.options.openedBy || this.options.openedBy === this.agent.publicKey,
+      yoloMode: configuration.yoloMode
+    };
+    let reviewerInstruction = cornerReviewerInstruction(reviewerInput);
+    if (reviewerInstruction) {
+      const restore = await this.options.api.execute("getCornerRestoreState", {
+        cornerId: this.options.cornerId
+      });
+      reviewerInstruction = cornerReviewerInstruction({
+        ...reviewerInput,
+        pullRequestNumber: restore.lifecycle?.pr?.number
+      });
+    }
+    this.cornerTurnEndNudge = reviewerInstruction ?? cornerMergeInstruction(configuration.yoloMode, configuration.reviewerHandle);
+    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,
@@ -21836,10 +22373,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({
@@ -21849,13 +22389,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: {
@@ -21867,7 +22407,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,
@@ -21896,7 +22442,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 }
           ]
         }
       ] : [],
@@ -21934,8 +22484,11 @@ var MonolithCornerTurnLoop = class {
         ...repository ? [
           `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
           `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),
+          ...reviewerInstruction ? [reviewerInstruction] : [
+            configuration.reviewerHandle ? `Once the pull request exists, reply with its full URL, then @${configuration.reviewerHandle} please review, and end the turn; do not check or wait for CI.` : '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.',
+            CORNER_AUTHOR_CONTRACT,
+            cornerMergeInstruction(configuration.yoloMode, configuration.reviewerHandle)
+          ],
           "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.",
           "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."
         ] : [
@@ -22056,7 +22609,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;
@@ -22158,7 +22711,7 @@ ${trigger}`,
             publishToolCalls(calls, false);
             await this.activityTail;
           };
-          const runPrompt = async () => {
+          const runPrompt = async (prompt = buildPrompt()) => {
             activityAttempt += 1;
             publishedToolCalls.clear();
             observedToolCalls.clear();
@@ -22170,7 +22723,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);
@@ -22202,6 +22755,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 || Boolean(this.reviewerHandle)))) {
+            if (needsDeliveryNudge)
+              this.lastDeliveryNudgeState = deliveryState;
+            replyBeforeNudge = durableReplyText(result.agentText);
+            await flushToolCalls(result.toolCalls, "");
+            result = await runPrompt(this.reviewerHandle ? this.cornerTurnEndNudge : checksTurn ? CORNER_YOLO_MERGE_NUDGE : CORNER_DELIVERY_NUDGE);
+            trace.promptSettled();
+            explained = await this.explainEmpty(result);
+          }
           if (this.stoppedTurns.has(requestId)) {
             stream.close();
             throw new TurnStoppedError("turn stopped by the requester");
@@ -22209,6 +22775,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);
@@ -22249,15 +22816,47 @@ ${trigger}`,
         requestId,
         status: "failed",
         generationId: this.commandContext.generationId,
-        reason
+        reason: reason.text,
+        ...reason.kind ? { reasonKind: reason.kind } : {}
       });
-      await trace.finish("failed", reason);
+      await trace.finish("failed", reason.text);
       throw error;
     } 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.
@@ -22304,6 +22903,7 @@ ${trigger}`,
           const state = await api.execute("getCornerRestoreState", { cornerId });
           if (!state.closeRequested)
             return false;
+          await this.harvest;
           await this.options.onCloseRequested();
           return true;
         },
@@ -22312,6 +22912,7 @@ ${trigger}`,
     } finally {
       this.options.grantRunner?.unregister(cornerId);
       await this.options.scheduler.suspend(cornerId);
+      await this.harvest;
     }
   }
 };
@@ -22732,13 +23333,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
@@ -22757,8 +23358,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",
@@ -22768,6 +23369,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}`,
@@ -22801,7 +23409,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 };
@@ -22867,11 +23475,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;
@@ -23061,13 +23669,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 {
@@ -23083,10 +23691,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 } : {}
     };
   }
@@ -23152,12 +23760,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
@@ -23210,9 +23818,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", {
@@ -23316,13 +23924,15 @@ var RoomRuntimeCoordinator = class {
       const asked = [...conversation.items].reverse().find((item) => item.type === "message" && item.mentionIds.includes(this.agent.publicKey));
       if (!asked)
         return;
+      const reason = distillTurnFailureReason(error);
       await this.options.daemonApi.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
         roomId: cornerId,
         requestId: asked.id,
         status: "failed",
         generationId: `${this.agent.publicKey}:${cornerId}`,
-        reason: distillTurnFailureReason(error)
+        reason: reason.text,
+        ...reason.kind ? { reasonKind: reason.kind } : {}
       });
     } catch (reportError) {
       console.error(`[thin-core] corner ${cornerId} start-failure report failed:`, reportError);
@@ -23595,9 +24205,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);
@@ -23639,9 +24249,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))
@@ -23649,8 +24259,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], {
@@ -23666,9 +24276,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;
@@ -23749,7 +24359,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;
@@ -23824,7 +24434,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."));
@@ -23840,9 +24450,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
@@ -24109,7 +24719,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,
@@ -24121,7 +24735,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,
@@ -24236,6 +24850,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) {
@@ -24253,13 +24873,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) {
@@ -24293,6 +24918,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({
@@ -24325,10 +24977,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;
@@ -24387,11 +25038,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) {
@@ -24416,12 +25069,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
@@ -24463,7 +25117,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve22(layout.binDir, "beeline"),
+    binary: resolve23(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -24486,21 +25140,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) {
@@ -24561,13 +25215,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,
@@ -24623,7 +25280,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);
@@ -24643,18 +25300,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
       });
@@ -24676,24 +25333,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);
@@ -24703,7 +25360,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;
@@ -24754,22 +25411,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)
@@ -24780,7 +25437,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 {
@@ -24883,7 +25540,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 = {
@@ -25170,7 +25827,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
@@ -25398,16 +26055,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;
     }
@@ -25419,10 +26076,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);
@@ -25438,13 +26095,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;
@@ -25538,11 +26195,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 = {
@@ -25572,7 +26229,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: {
@@ -25716,13 +26373,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";
@@ -25765,13 +26422,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 = "";
@@ -25781,7 +26438,7 @@ async function probeReleaseInSubprocess(input) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve30(outcome);
+      resolve31(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -25828,7 +26485,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
@@ -25846,7 +26503,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,
@@ -25854,15 +26511,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}$/;
@@ -25879,17 +26536,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) {
@@ -25898,10 +26555,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 [];
   }
@@ -25909,8 +26566,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);
   }
@@ -25919,7 +26576,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 };
   }
@@ -25928,15 +26585,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;
@@ -25954,7 +26611,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);
@@ -26015,7 +26672,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) {
@@ -26027,7 +26684,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,
@@ -26035,7 +26692,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
@@ -26070,7 +26727,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;
@@ -26186,7 +26843,8 @@ async function runStoredDaemon(pathOrPointer) {
           agentId: runtime.agent.publicKey,
           workspaceId: runtime.communityId,
           runtimeDir,
-          ...runtime.modelSelection ? { runtimeSelection: runtime.modelSelection } : {}
+          ...runtime.modelSelection ? { runtimeSelection: runtime.modelSelection } : {},
+          ...config.modelUnavailable ? { startupUnavailable: config.modelUnavailable.unavailable.label } : {}
         });
       },
       onProgress: async (status) => {
@@ -26217,8 +26875,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);
     }
@@ -26245,7 +26903,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 });
@@ -26294,14 +26952,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") {
@@ -26322,7 +26980,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);