usebeeline 0.0.63 → 0.0.69

package/dist/usebeeline.mjs

@@ -2415,7 +2415,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes7, createHash: createHash7 } = __require("crypto");
+    var { randomBytes: randomBytes7, createHash: createHash8 } = __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 = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3452,7 +3452,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash7 } = __require("crypto");
+    var { createHash: createHash8 } = __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 = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3984,12 +3984,12 @@ __export(self_update_exports, {
   writeUpdateAttemptFixture: () => writeUpdateAttemptFixture,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod as chmod4, lstat as lstat2, mkdir as mkdir13, open, readFile as readFile9, rename as rename3, rm as rm5, symlink as symlink2, writeFile as writeFile9 } from "node:fs/promises";
+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 { spawn as spawn4 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname9, join as join7, resolve as resolve21 } from "node:path";
+import { dirname as dirname10, join as join8, resolve as resolve21 } from "node:path";
 function anchorLayout(rawLibDir) {
   const libDir = resolve21(rawLibDir);
   const segments = libDir.split(/[/\\]/);
@@ -4028,7 +4028,7 @@ function discoveredBeelineInstallLayout(env = process.env) {
     return anchorLayout(explicitAnchor);
   const explicitBinDir = env.BEELINE_INSTALL_DIR?.trim();
   if (explicitBinDir)
-    return anchorLayout(resolve21(dirname9(resolve21(explicitBinDir)), "lib", "beeline"));
+    return anchorLayout(resolve21(dirname10(resolve21(explicitBinDir)), "lib", "beeline"));
   return defaultBeelineInstallLayout(env);
 }
 function hostPlatformKey() {
@@ -4039,7 +4039,7 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join7(bundleDir, "lib", "beeline", "bundle.json"), join7(bundleDir, "bundle.json")];
+  return [join8(bundleDir, "lib", "beeline", "bundle.json"), join8(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
@@ -4063,7 +4063,7 @@ async function readBundleJson(bundleDir) {
   }
 }
 function updateStatePath(layout) {
-  return join7(layout.releasesRoot, ".state", "update-state.json");
+  return join8(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
@@ -4073,8 +4073,8 @@ async function readUpdateState(layout) {
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir13(join7(layout.releasesRoot, ".state"), { recursive: true });
-  await writeFile9(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
+  await mkdir14(join8(layout.releasesRoot, ".state"), { recursive: true });
+  await writeFile10(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 async function readInstalledBundleIdentity(layout, _state = {}) {
@@ -4155,7 +4155,7 @@ function run(command, args, timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join7(bundleDir, BUNDLE_ENTRYPOINT), join7(bundleDir, "beeline-cli.mjs")];
+  return [join8(bundleDir, BUNDLE_ENTRYPOINT), join8(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
@@ -4177,8 +4177,8 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log2 = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   const releaseId = sanitizeReleaseId(published.commit ?? published.version ?? `release-${Date.now()}`);
-  const releaseDir = join7(layout.releasesRoot, releaseId);
-  const okMarker = join7(releaseDir, ".stage-ok");
+  const releaseDir = join8(layout.releasesRoot, releaseId);
+  const okMarker = join8(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
     const recorded = await readFile9(okMarker, "utf8");
@@ -4187,8 +4187,8 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     previouslyVerified = true;
   } catch {
   }
-  await mkdir13(releaseDir, { recursive: true });
-  const tempArchive = join7(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  await mkdir14(releaseDir, { recursive: true });
+  const tempArchive = join8(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 = createHash5("sha256");
+    const hash = createHash6("sha256");
     const chunks = [];
     for await (const chunk of response.body) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -4208,7 +4208,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (actual !== published.sha256.toLowerCase()) {
       throw new Error(`checksum mismatch for ${published.file}: expected ${published.sha256}, got ${actual} \u2014 aborting without touching the installed bundle`);
     }
-    await writeFile9(tempArchive, Buffer.concat(chunks), { mode: 384 });
+    await writeFile10(tempArchive, Buffer.concat(chunks), { mode: 384 });
     const entries = (await new Promise((resolveList, rejectList) => {
       const child = spawn4("tar", ["-tzf", tempArchive], { stdio: ["ignore", "pipe", "inherit"] });
       let out = "";
@@ -4228,18 +4228,18 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract2.stderr}`);
     for (const relative3 of requiredBundlePaths()) {
       try {
-        await access(join7(releaseDir, relative3), fsConstants.F_OK);
+        await access(join8(releaseDir, relative3), fsConstants.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative3}`);
       }
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join7(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
+      const probe = await run(process.execPath, [join8(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
       if (probe.status !== 0) {
         throw new Error(`staged bundle failed its startup smoke test (--version exited ${probe.status})${probe.stderr ? `: ${probe.stderr.trim()}` : ""}`);
       }
     }
-    await writeFile9(okMarker, `${published.sha256}
+    await writeFile10(okMarker, `${published.sha256}
 `, "utf8");
     log2(`staged release ${releaseId} (sha256 verified)`);
     return releaseId;
@@ -4267,26 +4267,26 @@ function forwarderScript(tool) {
 }
 async function replaceFile(path, contents, mode) {
   const temp = `${path}.new-${process.pid}`;
-  await writeFile9(temp, contents, { mode });
+  await writeFile10(temp, contents, { mode });
   await chmod4(temp, mode);
   await rename3(temp, path);
 }
 async function activateRelease(layout, releaseId) {
-  const releaseDir = join7(layout.releasesRoot, releaseId);
-  await access(join7(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
-  await mkdir13(layout.releasesRoot, { recursive: true });
-  await mkdir13(layout.binDir, { recursive: true });
+  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 });
   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 = join7(layout.releasesRoot, legacyId);
+    const legacyDir = join8(layout.releasesRoot, legacyId);
     try {
       await access(legacyDir, fsConstants.F_OK);
       previousReleaseId = `${legacyId}-${Date.now()}`;
-      await rename3(layout.libDir, join7(layout.releasesRoot, previousReleaseId));
-      await normalizeLegacyBundleShape(join7(layout.releasesRoot, previousReleaseId));
+      await rename3(layout.libDir, join8(layout.releasesRoot, previousReleaseId));
+      await normalizeLegacyBundleShape(join8(layout.releasesRoot, previousReleaseId));
     } catch {
       await rename3(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
@@ -4295,18 +4295,18 @@ async function activateRelease(layout, releaseId) {
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
   await rm5(tempLink, { force: true });
-  await symlink2(join7("beeline-releases", releaseId), tempLink);
+  await symlink2(join8("beeline-releases", releaseId), tempLink);
   await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname9(layout.libDir));
+  await fsyncDir(dirname10(layout.libDir));
   await writeBinForwarders(layout, releaseDir);
   return { previousReleaseId };
 }
 async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join7(bundleDir, "lib", "beeline");
+  const innerLib = join8(bundleDir, "lib", "beeline");
   let anyFlat = false;
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join7(bundleDir, name), fsConstants.F_OK);
+      await access(join8(bundleDir, name), fsConstants.F_OK);
       anyFlat = true;
       break;
     } catch {
@@ -4314,14 +4314,14 @@ async function normalizeLegacyBundleShape(bundleDir) {
   }
   if (!anyFlat)
     return;
-  await mkdir13(innerLib, { recursive: true });
+  await mkdir14(innerLib, { recursive: true });
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join7(innerLib, name), fsConstants.F_OK);
+      await access(join8(innerLib, name), fsConstants.F_OK);
       continue;
     } catch {
     }
-    await rename3(join7(bundleDir, name), join7(innerLib, name)).catch(() => void 0);
+    await rename3(join8(bundleDir, name), join8(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 = join7(activeBundleRoot, "bin", tool);
+    const target = join8(activeBundleRoot, "bin", tool);
     try {
       await access(target, fsConstants.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join7(layout.binDir, name), forwarderScript(tool), 493);
+    await replaceFile(join8(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(join7(layout.binDir, name), "utf8");
+      current = await readFile9(join8(layout.binDir, name), "utf8");
     } catch {
       current = void 0;
     }
@@ -4358,25 +4358,25 @@ async function repairInstallForwarders(layout, opts = {}) {
   }
   if (healthy)
     return false;
-  await mkdir13(layout.binDir, { recursive: true });
+  await mkdir14(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 = join7(layout.releasesRoot, previousReleaseId);
+  const releaseDir = join8(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(join7("beeline-releases", previousReleaseId), tempLink);
+  await symlink2(join8("beeline-releases", previousReleaseId), tempLink);
   await rename3(tempLink, layout.libDir);
-  await fsyncDir(dirname9(layout.libDir));
+  await fsyncDir(dirname10(layout.libDir));
 }
 function updateAttemptPath(layout) {
-  return join7(layout.releasesRoot, ".state", "update-attempt.json");
+  return join8(layout.releasesRoot, ".state", "update-attempt.json");
 }
 async function readUpdateAttempt(layout) {
   try {
@@ -4390,10 +4390,10 @@ async function readUpdateAttempt(layout) {
   }
 }
 async function writeUpdateAttempt(layout, record2) {
-  await mkdir13(join7(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir14(join8(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateAttemptPath(layout);
   const staged = `${path}.${process.pid}.tmp`;
-  await writeFile9(staged, `${JSON.stringify(record2, null, 2)}
+  await writeFile10(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
   await rename3(staged, path);
 }
@@ -4655,8 +4655,8 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname15, resolve as resolve29 } from "node:path";
-import { readFile as readFile14, unlink as unlink5, writeFile as writeFile15 } from "node:fs/promises";
+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 { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -6663,20 +6663,6 @@ var ACCESS_NOTICE_WINDOW_MS = 10 * 6e4;
 var DEFAULT_ACCESS_POLICY = DEFAULT_AGENT_ACCESS_POLICY;
 var LEGACY_ACCESS_POLICY = "everyone";
 var ACCESS_REFUSAL_WINDOW_MS = 60 * 60 * 1e3;
-function isSenderPermitted(policy, senderPubkey, ownerPubkey, allowlist = void 0) {
-  if (!senderPubkey)
-    return false;
-  switch (policy) {
-    case "everyone":
-      return true;
-    case "creator":
-      return Boolean(ownerPubkey) && senderPubkey === ownerPubkey;
-    case "allowlist":
-      return Boolean(allowlist?.includes(senderPubkey));
-    default:
-      return false;
-  }
-}
 
 // apps/body/dist/model-catalog.js
 import { mkdtemp, rm } from "node:fs/promises";
@@ -6912,8 +6898,13 @@ function agentMessageRuns(updates, agentLabel) {
   let current = "";
   let lastWasText = false;
   for (const u4 of updates) {
+    const isToolCall = u4.update.sessionUpdate === "tool_call";
     const delta = normalizeStreamDelta(agentMessageChunkText(u4.update), agentLabel);
     if (!delta) {
+      if (isToolCall && current) {
+        runs.push(current);
+        current = "";
+      }
       lastWasText = false;
       continue;
     }
@@ -6934,9 +6925,6 @@ function agentMessageRuns(updates, agentLabel) {
     return true;
   });
 }
-function joinAgentMessageChunks(updates, agentLabel) {
-  return agentMessageRuns(updates, agentLabel).join("\n\n");
-}
 var RETRY_NARRATION_FRAGMENTS = [
   // `Retrying (attempt 2/3, waiting 4s)` — the pi/ox-alpha shape.
   /retrying\s*\((?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?\)/gi,
@@ -7065,6 +7053,7 @@ function toolCallEntries(updates) {
       ...typeof update.title === "string" ? { title: update.title } : {},
       ...typeof update.kind === "string" ? { kind: update.kind } : {},
       ...typeof update.status === "string" ? { status: update.status } : {},
+      ...sessionUpdate === "tool_result" ? { resultReceived: true } : {},
       ..."rawInput" in update ? { rawInput: update.rawInput } : {},
       ..."content" in update ? { content: update.content } : {},
       ..."rawOutput" in update ? { rawOutput: update.rawOutput } : {},
@@ -7327,8 +7316,10 @@ var AcpClient = class extends EventEmitter {
       onToolCalls?.(toolCallEntries(updates));
       if (onChunk) {
         const delta = agentMessageChunkText(u4.update);
-        if (delta)
-          onChunk(delta, joinAgentMessageChunks(updates, this.agentLabel));
+        if (delta) {
+          const runs = agentMessageRuns(updates, this.agentLabel);
+          onChunk(delta, runs.join("\n\n"), runs.at(-1), runs);
+        }
       }
     };
     this.on("session/update", onUpdate);
@@ -8124,6 +8115,40 @@ async function syncAgentModelCatalog(input) {
   }
 }
 
+// packages/api-contract/dist/daemon-operations.js
+function isAgentCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c2 = value;
+  if (![
+    "id",
+    "roomId",
+    "agentId",
+    "sourceMessageId",
+    "turnRequestId",
+    "rootCommandId",
+    "rootSourceMessageId",
+    "reason"
+  ].every((key) => typeof c2[key] === "string" && c2[key].length > 0))
+    return false;
+  if (!["input", "resume", "stop"].includes(String(c2.action)) || !Number.isInteger(c2.agentDepth) || Number(c2.agentDepth) < 0 || Number(c2.agentDepth) > 3)
+    return false;
+  const source = c2.source;
+  return Boolean(source && typeof source.id === "string" && typeof source.authorId === "string" && typeof source.body === "string" && typeof source.createdAt === "number" && Array.isArray(source.attachments) && Array.isArray(source.mentionIds));
+}
+
+// packages/api-contract/dist/system-events.js
+var SERVER_EVENT_KINDS = [
+  "joined",
+  "schedule-ran",
+  "corner-opened",
+  "check-passed",
+  "check-failed",
+  "merged",
+  "grant-decided",
+  "turn-cancelled"
+];
+
 // apps/body/dist/daemon-api-client.js
 import { resolve as resolve7 } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -16905,20 +16930,6 @@ var DaemonApiError = class extends Error {
   }
 };
 var AGENT_REMOVED_CODE = "agent_removed";
-function laterInboxCursor(left, right) {
-  if (!left)
-    return right;
-  if (!right)
-    return left;
-  const leftMatch = left.match(/^(\d+),([0-9a-f]{64})$/);
-  const rightMatch = right.match(/^(\d+),([0-9a-f]{64})$/);
-  if (!leftMatch || !rightMatch)
-    return right;
-  const timeOrder = BigInt(leftMatch[1]) - BigInt(rightMatch[1]);
-  if (timeOrder !== 0n)
-    return timeOrder > 0n ? left : right;
-  return leftMatch[2] >= rightMatch[2] ? left : right;
-}
 function isAgentRemovedError(error) {
   return error instanceof DaemonApiError && error.status === 403 && error.code === AGENT_REMOVED_CODE;
 }
@@ -16958,20 +16969,23 @@ var DaemonApiClient = class {
     return { baseUrl: this.baseUrl, daemonToken: this.daemonToken, agentId: this.agentId };
   }
   /** Add one Room to this agent's shared live socket. */
-  liveSubscribe(roomId, cursor3, onItems, onState, presence) {
+  liveSubscribe(roomId, cursor3, onItems, onState, presence, onCommands) {
     const existing = this.liveRooms.get(roomId);
     if (existing) {
       existing.cursor = cursor3 ?? existing.cursor;
       existing.onItems = onItems ?? existing.onItems;
       existing.onState = onState ?? existing.onState;
       existing.presence = presence ?? existing.presence;
+      existing.onCommands = onCommands ?? existing.onCommands;
     } else {
       this.liveRooms.set(roomId, {
         ...cursor3 ? { cursor: cursor3 } : {},
         pushedIds: /* @__PURE__ */ new Set(),
+        pushedCommandIds: /* @__PURE__ */ new Set(),
         ...onItems ? { onItems } : {},
         ...onState ? { onState } : {},
-        ...presence ? { presence } : {}
+        ...presence ? { presence } : {},
+        ...onCommands ? { onCommands } : {}
       });
     }
     this.ensureLiveSocket();
@@ -17041,6 +17055,22 @@ var DaemonApiClient = class {
         });
         return;
       }
+      if (event.type === "commands" && typeof event.roomId === "string" && event.commandProtocol === 1 && Array.isArray(event.commands)) {
+        const room2 = this.liveRooms.get(event.roomId);
+        if (!room2)
+          return;
+        const commands = event.commands.filter((command) => {
+          if (!isAgentCommand(command) || command.roomId !== event.roomId || command.agentId !== this.agentId || room2.pushedCommandIds.has(command.id))
+            return false;
+          room2.pushedCommandIds.add(command.id);
+          return true;
+        });
+        while (room2.pushedCommandIds.size > 1e4)
+          room2.pushedCommandIds.delete(room2.pushedCommandIds.values().next().value);
+        if (commands.length)
+          room2.onCommands?.(commands);
+        return;
+      }
       if (event.type !== "inbox" || typeof event.roomId !== "string" || !Array.isArray(event.items))
         return;
       const room = this.liveRooms.get(event.roomId);
@@ -17134,10 +17164,10 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 
 // apps/body/dist/room-runtime.js
 import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
-import { mkdir as mkdir11, rm as rm4 } from "node:fs/promises";
-import { dirname as dirname6, resolve as resolve19 } from "node:path";
+import { mkdir as mkdir12, rm as rm4 } from "node:fs/promises";
+import { dirname as dirname7, resolve as resolve19 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // apps/body/dist/grant-runner.js
@@ -17190,18 +17220,6 @@ function commandGrantMatches(rule, requested) {
   return rule.argv.every((word, index) => requested[index] === word);
 }
 var DECISION_LINE = new RegExp(`^(.+?) (approved once|approved|declined) (${AGENT_GRANT_KINDS.join("|")}) (.+)$`, "s");
-function parseGrantDecisionLine(body) {
-  const match = DECISION_LINE.exec(body);
-  if (!match)
-    return void 0;
-  const decision2 = match[2] === "approved once" ? "once" : match[2] === "approved" ? "always" : "deny";
-  return {
-    deciderName: match[1],
-    decision: decision2,
-    kind: match[3],
-    target: match[4]
-  };
-}
 var AGENT_GRANT_ESCALATION_REASONS = {
   "unseen-script": "it runs a script whose contents nobody has read",
   credential: "it names a credential or environment file"
@@ -17781,7 +17799,9 @@ var GrantCommandRunner = class {
     if (!room)
       throw new Error("this daemon is not serving that Room");
     const argv = validateGrantArgv(input.argv);
-    const live = await this.options.api.execute("listAgentGrants", { agentId: this.options.agentId });
+    const live = await this.options.api.execute("listAgentGrants", {
+      agentId: this.options.agentId
+    });
     const match = matchCommandGrant(live.grants, room.workspaceId, argv);
     if (!match) {
       throw new Error(`no approved command grant matches: ${argv.join(" ")}. Ask with request_grant kind=command first.`);
@@ -17844,6 +17864,7 @@ ${ROOM_WRITE_REFUSED_NOTE}` : outcome.output, secrets), cap);
       agentId: this.options.agentId,
       roomId: input.roomId,
       requestId: turn?.requestId ?? `grant:${grant.grantId}`,
+      generationId: turn?.generationId,
       activity: [
         {
           kind: "tool",
@@ -17898,7 +17919,10 @@ function scriptCandidates(cwd, scratch, argv) {
   const argument = interpreterScriptArgument(argv);
   if (!argument)
     return [];
-  const paths = [resolve10(cwd, argument.path), ...scratch ? [resolve10(scratch, argument.path)] : []];
+  const paths = [
+    resolve10(cwd, argument.path),
+    ...scratch ? [resolve10(scratch, argument.path)] : []
+  ];
   return [...new Set(paths)];
 }
 function roomSandboxCommand(policy, cwd, argv) {
@@ -17977,42 +18001,167 @@ var GrantRunnerServer = class {
   }
 };
 
+// apps/body/dist/server-command-intake.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname5, join as join3 } from "node:path";
+var CommandExecutionContext = class {
+  generationId = randomUUID2();
+  path;
+  current;
+  constructor(root) {
+    this.path = join3(root ?? tmpdir2(), `beeline-command-${this.generationId}.json`);
+  }
+  async enter(command) {
+    this.current = command;
+    await mkdir3(dirname5(this.path), { recursive: true });
+    await writeFile4(this.path, JSON.stringify({
+      roomId: command.roomId,
+      requestId: command.turnRequestId,
+      generationId: this.generationId
+    }), { mode: 384 });
+  }
+  async leave() {
+    this.current = void 0;
+    await writeFile4(this.path, "{}", { mode: 384 });
+  }
+  bind(api) {
+    return new Proxy(api, {
+      get: (target, key) => {
+        if (key === "execute")
+          return (name, input) => {
+            const turn = this.current;
+            return target.execute(name, {
+              ...input,
+              ...turn && (input.roomId === turn.roomId || input.cornerId === turn.roomId) ? {
+                generationId: this.generationId,
+                requestId: input.requestId ?? input.turnId ?? turn.turnRequestId
+              } : {}
+            });
+          };
+        const value = Reflect.get(target, key);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  }
+};
+function validateServerCommand(command, roomId, agentId) {
+  if (!isAgentCommand(command) || command.roomId !== roomId || command.agentId !== agentId)
+    throw new Error("invalid server command");
+}
+async function runServerCommandIntake(options) {
+  const { api, roomId, agentId, context, signal } = options;
+  const first = await api.execute("getAgentCommands", { roomId });
+  if (first?.commandProtocol !== 1)
+    throw new Error("server command protocol 1 is required; refusing intake");
+  let busy;
+  let wake;
+  const pending = new Map(first.commands.map((command) => [command.id, command]));
+  const claimed = /* @__PURE__ */ new Set();
+  const notify2 = (commands = []) => {
+    for (const command of commands)
+      if (!claimed.has(command.id))
+        pending.set(command.id, command);
+    wake?.(false);
+  };
+  options.onWake?.(notify2);
+  const off = api.liveSubscribe?.(roomId, void 0, void 0, (connected) => {
+    if (!connected)
+      wake?.(true);
+  }, options.presence, notify2);
+  try {
+    while (!signal?.aborted) {
+      if (options.closed && await options.closed())
+        return;
+      for (const command of [...pending.values()]) {
+        validateServerCommand(command, roomId, agentId);
+        if (busy && command.action !== "stop")
+          continue;
+        pending.delete(command.id);
+        try {
+          await api.execute("claimAgentCommand", {
+            roomId,
+            commandId: command.id,
+            generationId: context.generationId
+          });
+        } catch (error) {
+          options.onError?.(error);
+          continue;
+        }
+        claimed.add(command.id);
+        if (command.action === "stop") {
+          options.stop(command.turnRequestId);
+          await api.execute("acknowledgeAgentCommand", {
+            roomId,
+            commandId: command.id,
+            generationId: context.generationId
+          });
+        } else {
+          await context.enter(command);
+          busy = options.run(command).catch((error) => {
+            claimed.delete(command.id);
+            options.onError?.(error);
+          }).finally(async () => {
+            await context.leave();
+            busy = void 0;
+            notify2();
+          });
+        }
+      }
+      options.onPoll?.();
+      const reconcile = await new Promise((resolve30) => {
+        const done = (needed) => {
+          if (timer)
+            clearTimeout(timer);
+          signal?.removeEventListener("abort", aborted);
+          wake = void 0;
+          resolve30(needed);
+        };
+        const aborted = () => done(false);
+        wake = done;
+        const timer = setTimeout(() => done(true), options.pollMs ?? 1e3);
+        signal?.addEventListener("abort", aborted, { once: true });
+        if (pending.size && !busy)
+          done(false);
+      });
+      if (signal?.aborted)
+        break;
+      if (reconcile) {
+        const page = await api.execute("getAgentCommands", { roomId });
+        if (page.commandProtocol !== 1)
+          throw new Error("server command protocol changed; refusing intake");
+        notify2(page.commands);
+      }
+    }
+  } finally {
+    off?.();
+    options.onWake?.(void 0);
+    if (context.current)
+      options.stop(context.current.turnRequestId);
+    await busy;
+  }
+}
+
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir9 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir11 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join7 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // apps/body/dist/agent-home.js
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import { chmod as chmod2, copyFile, lstat, mkdir as mkdir4, readFile as readFile6, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile5 } from "node:fs/promises";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { chmod as chmod2, copyFile, lstat, mkdir as mkdir5, readFile as readFile6, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename3, dirname as dirname5, join as join3, relative as relative2, resolve as resolve13, sep } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join4, relative as relative2, resolve as resolve13, sep } from "node:path";
 
 // apps/body/dist/beeline-skill.js
 import { readFileSync as readFileSync3 } from "node:fs";
 import { resolve as resolve11 } from "node:path";
 
-// packages/api-contract/dist/system-events.js
-var SERVER_EVENT_KINDS = [
-  "joined",
-  "schedule-ran",
-  "corner-opened",
-  "check-passed",
-  "check-failed",
-  "merged",
-  "grant-decided"
-];
-function isServerEventKind(value) {
-  return SERVER_EVENT_KINDS.includes(value);
-}
-var RESUME_KINDS = ["grant-decided"];
-function isResumeKind(value) {
-  return RESUME_KINDS.includes(value);
-}
-
 // packages/api-contract/dist/agent-pairing-code.js
 var CURRENT_AGENT_PAIRING_CODE = /^[0-9A-F]{8}-[0-9A-F]{8}$/;
 var LEGACY_AGENT_PAIRING_CODE = /^BUZZ-(?:[0-9A-F]{8}-[0-9A-F]{8}|[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4})$/;
@@ -18110,7 +18259,7 @@ var SQUIRE_GOVERNED_TOOLS = [
 var SQUIRE_GOVERNED_TOOL_SET = new Set(SQUIRE_GOVERNED_TOOLS);
 
 // apps/body/dist/openrouter-routing.js
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 import { resolve as resolve12 } from "node:path";
 var OPENROUTER_ENDPOINTS_BASE_URL = "https://openrouter.ai/api/v1/models";
 var OPENROUTER_COMPLETIONS_URL = "https://openrouter.ai/api/v1/chat/completions";
@@ -18240,8 +18389,8 @@ async function readCache(cacheDir, model) {
   }
 }
 async function writeCache(cacheDir, value) {
-  await mkdir3(cacheDir, { recursive: true, mode: 448 });
-  await writeFile4(cachePath(cacheDir, value.model), `${JSON.stringify(value, null, 2)}
+  await mkdir4(cacheDir, { recursive: true, mode: 448 });
+  await writeFile5(cachePath(cacheDir, value.model), `${JSON.stringify(value, null, 2)}
 `, {
     mode: 384
   });
@@ -18275,8 +18424,8 @@ async function readProbeCache(cacheDir, model) {
   }
 }
 async function writeProbeCache(cacheDir, value) {
-  await mkdir3(cacheDir, { recursive: true, mode: 448 });
-  await writeFile4(probeCachePath(cacheDir, value.model), `${JSON.stringify(value, null, 2)}
+  await mkdir4(cacheDir, { recursive: true, mode: 448 });
+  await writeFile5(probeCachePath(cacheDir, value.model), `${JSON.stringify(value, null, 2)}
 `, {
     mode: 384
   });
@@ -18732,14 +18881,14 @@ async function prepareRoomAgentHome(input) {
   const root = resolve13(input.root);
   const operatorHome = input.operatorHome ?? homedir5();
   try {
-    await mkdir4(root, { recursive: true, mode: 448 });
+    await mkdir5(root, { recursive: true, mode: 448 });
     const rootStats = await lstat(root);
     if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) {
       throw new AgentHomeSecurityError(`agent home root is not an ordinary directory: ${root}`);
     }
     for (const subdir of HOME_SUBDIRS) {
       const path = resolve13(root, subdir);
-      await mkdir4(path, { recursive: true, mode: 448 });
+      await mkdir5(path, { recursive: true, mode: 448 });
       await assertRealContainedDirectory(path, root);
     }
   } catch (error) {
@@ -18791,7 +18940,7 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
   }
   try {
     const gooseConfigDir = resolve13(root, "goose", "config");
-    await mkdir4(gooseConfigDir, { recursive: true, mode: 448 });
+    await mkdir5(gooseConfigDir, { recursive: true, mode: 448 });
     for (const name of GOOSE_SHARED_CONFIG_FILES) {
       const source = resolve13(operatorHome, ".config", "goose", name);
       const target = resolve13(gooseConfigDir, name);
@@ -18903,18 +19052,18 @@ function filteredHarnessMcpToml(source) {
   return extractTomlSections(source, ["mcp_servers"], excluded);
 }
 async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, optionalShares) {
-  const parent = dirname5(target);
-  await assertRealContainedDirectory(parent, dirname5(parent));
+  const parent = dirname6(target);
+  await assertRealContainedDirectory(parent, dirname6(parent));
   const plan = await planManagedSkills(managedSkills, sharedSkills, optionalShares);
   if (await materializedSkillManifest(target) === plan.manifest)
     return;
-  const staged = resolve13(parent, `.skills.${process.pid}.${randomUUID2()}.tmp`);
-  await mkdir4(staged, { mode: 448 });
+  const staged = resolve13(parent, `.skills.${process.pid}.${randomUUID3()}.tmp`);
+  await mkdir5(staged, { mode: 448 });
   try {
     for (const entry of plan.entries) {
       if (entry.kind === "managed") {
         const skillDir = resolve13(staged, entry.name);
-        await mkdir4(skillDir, { recursive: true });
+        await mkdir5(skillDir, { recursive: true });
         await writeIsolatedHarnessFile(resolve13(skillDir, "SKILL.md"), entry.content);
       } else {
         await copySafeSkillTree(entry.source, resolve13(staged, entry.name), entry.source);
@@ -18944,8 +19093,8 @@ async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
     try {
       const tree = [];
       await walkSafeSkillTree(shared.source, shared.source, {
-        directory: async (rel) => void tree.push(`d ${join3(shared.name, rel)}`),
-        file: async (rel, realPath) => void tree.push(`f ${join3(shared.name, rel)} ${sha2563(await readFile6(realPath))}`)
+        directory: async (rel) => void tree.push(`d ${join4(shared.name, rel)}`),
+        file: async (rel, realPath) => void tree.push(`f ${join4(shared.name, rel)} ${sha2563(await readFile6(realPath))}`)
       });
       entries.push({ kind: "shared", name: shared.name, source: shared.source });
       lines.push(...tree);
@@ -18965,7 +19114,7 @@ async function materializedSkillManifest(target) {
   const visit = async (directory, prefix) => {
     for (const entry of await readdir2(directory)) {
       const path = resolve13(directory, entry);
-      const rel = prefix ? join3(prefix, entry) : entry;
+      const rel = prefix ? join4(prefix, entry) : entry;
       const entryStats = await lstat(path);
       if (entryStats.isSymbolicLink())
         return false;
@@ -19133,7 +19282,7 @@ async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
     for (const entry of await readdir2(resolvedSource)) {
       if (entry === "." || entry === "..")
         throw new Error("invalid shared skill entry");
-      await walkSafeSkillTree(resolve13(source, entry), sourceRoot, visitor, rel ? join3(rel, entry) : entry);
+      await walkSafeSkillTree(resolve13(source, entry), sourceRoot, visitor, rel ? join4(rel, entry) : entry);
     }
     return;
   }
@@ -19145,7 +19294,7 @@ async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
 async function copySafeSkillTree(source, target, sourceRoot) {
   await walkSafeSkillTree(source, sourceRoot, {
     directory: async (rel) => {
-      await mkdir4(resolve13(target, rel), { mode: 448 });
+      await mkdir5(resolve13(target, rel), { mode: 448 });
     },
     file: async (rel, realPath) => {
       const destination = resolve13(target, rel);
@@ -19155,14 +19304,14 @@ async function copySafeSkillTree(source, target, sourceRoot) {
   });
 }
 async function writeIsolatedHarnessFile(path, content) {
-  const parent = dirname5(path);
+  const parent = dirname6(path);
   const parentStats = await lstat(parent);
   if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
     throw new Error(`isolated harness parent is not a real directory: ${parent}`);
   }
-  const temporary = resolve13(parent, `.${basename3(path)}.${process.pid}.${randomUUID2()}.tmp`);
+  const temporary = resolve13(parent, `.${basename3(path)}.${process.pid}.${randomUUID3()}.tmp`);
   try {
-    await writeFile5(temporary, content, { mode: 384, flag: "wx" });
+    await writeFile6(temporary, content, { mode: 384, flag: "wx" });
     await chmod2(temporary, 384);
     await rename2(temporary, path);
   } finally {
@@ -19205,8 +19354,8 @@ function harnessStateDirsFromEnv(env) {
 }
 
 // apps/body/dist/attachment-delivery.js
-import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename4, extname, join as join4 } from "node:path";
+import { mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
+import { basename as basename4, extname, join as join5 } from "node:path";
 var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 var MEDIA_TTL_HOURS = 24;
 var EXPIRED_REASON = `expired: attachments are kept for ${MEDIA_TTL_HOURS} hours and these bytes are past that window`;
@@ -19226,7 +19375,7 @@ async function deliverAttachments(attachments, dir, fetchImpl = fetch) {
   if (!attachments.length)
     return [];
   const taken = /* @__PURE__ */ new Set();
-  await mkdir5(dir, { recursive: true });
+  await mkdir6(dir, { recursive: true });
   return Promise.all(attachments.map(async (attachment, index) => {
     const tooLarge = (bytes) => ({
       attachment,
@@ -19250,8 +19399,8 @@ async function deliverAttachments(attachments, dir, fetchImpl = fetch) {
       const bytes = Buffer.from(await response.arrayBuffer());
       if (bytes.length > MAX_ATTACHMENT_BYTES)
         return tooLarge(bytes.length);
-      const path = join4(dir, safeFileName(attachment, index, taken));
-      await writeFile6(path, bytes);
+      const path = join5(dir, safeFileName(attachment, index, taken));
+      await writeFile7(path, bytes);
       const mimeType = attachment.mimeType ?? response.headers.get("content-type") ?? "";
       if (!mimeType.startsWith("image/"))
         return { attachment, path };
@@ -19433,6 +19582,11 @@ function isCornerStatusRestatement(reply, systemLines) {
   return statusWords(text2).every((word) => !word || admitted.has(word));
 }
 
+// apps/body/dist/turn-stop.js
+var TurnStoppedError = class extends Error {
+  name = "TurnStoppedError";
+};
+
 // apps/body/dist/turn-stream.js
 function durableReplyText(agentText) {
   return sanitizeAgentReply(agentText);
@@ -19491,7 +19645,8 @@ var AgentTurnStream = class {
   /**
    * Everything the delta hook has seen this turn: every assistant run joined,
    * which is a LONGER string than `PromptResult.agentText` whenever the turn
-   * spoke before a tool call. Nothing durable is derived from it.
+   * spoke before a tool call. This final-reply lane derives nothing durable
+   * from it; a corner records its current normalized run independently.
    */
   get streamedText() {
     return this.latest;
@@ -19514,17 +19669,18 @@ var AgentTurnStream = class {
    * An empty reply settles through the turn receipt instead, and the lane is
    * retracted either way.
    */
-  async settle(reply, fields = {}) {
+  async settle(reply, fields = {}, onReplyPosted) {
     this.close();
     const { api, agentId, roomId, requestId } = this.options;
     if (reply) {
-      await api.execute("postRoomMessage", {
+      const posted = await api.execute("postRoomMessage", {
         roomId,
         requestId,
         text: reply,
         presentation: "message",
         ...fields
       });
+      onReplyPosted?.(posted);
     }
     await this.inFlight;
     await api.execute("retractAgentLiveOutput", {
@@ -19602,7 +19758,7 @@ function sessionConfigFingerprint(input) {
 }
 
 // apps/body/dist/pi-mcp-bridge.js
-import { mkdir as mkdir6 } from "node:fs/promises";
+import { mkdir as mkdir7 } from "node:fs/promises";
 import { resolve as resolve14 } from "node:path";
 var PI_MCP_BRIDGE_FILENAME = "beeline-mcp-bridge.js";
 function harnessMountsSessionMcpServers(agentCommand) {
@@ -19626,7 +19782,7 @@ async function installPiMcpBridge(input) {
   const directory = resolve14(input.piHome, "extensions");
   const path = resolve14(directory, PI_MCP_BRIDGE_FILENAME);
   try {
-    await mkdir6(directory, { recursive: true, mode: 448 });
+    await mkdir7(directory, { recursive: true, mode: 448 });
     await writeIsolatedHarnessFile(path, piMcpBridgeSource(input.servers));
     return path;
   } catch (error) {
@@ -20031,6 +20187,7 @@ function beelineAgentMcpServer(config, api, context) {
     args: [...config.readonlyMcpArgs ?? []],
     env: [
       { name: "BEELINE_MCP_SURFACE", value: "agent" },
+      ...context.turnContextPath ? [{ name: "BEELINE_TURN_CONTEXT_FILE", value: context.turnContextPath }] : [],
       ...context.directMessage ? [{ name: "BEELINE_AGENT_DM", value: "1" }] : [],
       { name: "BEELINE_DAEMON_BASE_URL", value: connection.baseUrl },
       { name: "BEELINE_DAEMON_TOKEN", value: connection.daemonToken },
@@ -20236,26 +20393,6 @@ function isAccountOrProviderRefusal(record2) {
   return [401, 402, 403, 407, 408, 429].includes(record2.status) || record2.status >= 500;
 }
 
-// apps/body/dist/corner-checks.js
-var COMPLETED_CHECK_NOTE = /\b(passed|failed) a check\b/i;
-var STARTED_CHECK_NOTE = /\bstarted a check\b/i;
-function verbOf(item) {
-  return item.systemEvent?.verb ?? item.body;
-}
-function completedCheckNote(item) {
-  if (item.type !== "system")
-    return void 0;
-  const match = COMPLETED_CHECK_NOTE.exec(verbOf(item));
-  return match ? match[1].toLowerCase() : void 0;
-}
-function isCheckStartNote(item) {
-  return item.type === "system" && STARTED_CHECK_NOTE.test(verbOf(item));
-}
-function checksStateFromLifecycle(lifecycle) {
-  const state = lifecycle?.checksSummary?.status ?? lifecycle?.checks;
-  return state === "passing" || state === "failing" || state === "pending" ? state : void 0;
-}
-
 // apps/body/dist/response-directives.js
 var MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE = "Maintain your assigned identity and soul in every response, including when tools or permissions block the requested action.";
 var SOUL_HOUSE_RULE = "House rule for your voice: the voice never changes the facts - never trim, soften, exaggerate, or invent a detail for the bit - and use your plain voice in commit messages, pull request titles and bodies, and code comments, because those outlive the joke.";
@@ -20295,7 +20432,6 @@ ${transcript}`;
 // apps/body/dist/turn-receipt-heartbeat.js
 var TURN_RECEIPT_HEARTBEAT_MS = 3e4;
 async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
-  await api.execute("postAgentTurnReceipt", { ...receipt, status: "working" });
   let tail = Promise.resolve();
   const timer = setInterval(() => {
     tail = tail.catch(() => void 0).then(() => api.execute("postAgentTurnReceipt", {
@@ -20314,7 +20450,7 @@ async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
 }
 
 // apps/body/dist/turn-trace.js
-import { appendFile, mkdir as mkdir7, readdir as readdir4, rm as rm3 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir8, readdir as readdir4, rm as rm3 } from "node:fs/promises";
 import { resolve as resolve17 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 var TURN_PHASES = [
@@ -20568,7 +20704,7 @@ var TurnTraceFile = class {
     this.tail = this.tail.catch(() => void 0).then(async () => {
       const now2 = (this.options.clock ?? (() => /* @__PURE__ */ new Date()))();
       const path = this.path(now2);
-      await mkdir7(this.directory, { recursive: true, mode: 448 });
+      await mkdir8(this.directory, { recursive: true, mode: 448 });
       await appendFile(path, `${JSON.stringify(record2)}
 `, { mode: 384 });
       await this.prune(now2);
@@ -20591,11 +20727,11 @@ var TurnTraceFile = class {
 };
 
 // apps/body/dist/corner-github-auth.js
-import { chmod as chmod3, mkdir as mkdir8, writeFile as writeFile7 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
 import { delimiter as delimiter2, resolve as resolve18 } from "node:path";
 async function installCornerGitHubWrappers(input) {
   const bin = resolve18(input.root, "beeline-github-bin");
-  await mkdir8(bin, { recursive: true, mode: 448 });
+  await mkdir9(bin, { recursive: true, mode: 448 });
   const common = {
     node: process.execPath,
     cli: input.cliEntrypoint,
@@ -20637,149 +20773,118 @@ if (result.stderr) process.stderr.write(result.stderr);
 if (result.error) throw result.error;
 process.exit(result.status ?? 1);
 `;
-  await writeFile7(path, source, { mode: 448 });
+  await writeFile8(path, source, { mode: 448 });
   await chmod3(path, 448);
 }
 
-// apps/body/dist/monolith-corner-turn.js
-var execFileAsync3 = promisify3(execFile4);
-var TOOL_ARGUMENT_MAX_BYTES = 1200;
-var TOOL_OUTPUT_MAX_BYTES = 3200;
-var TOOL_PATH_LIMIT = 12;
-function oneLine(value) {
-  return value.replace(/\s+/g, " ").trim();
+// apps/body/dist/monolith-room-turn.js
+import { mkdir as mkdir10 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } 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
+function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
+  if (isSquireMcpPermissionRequest(request))
+    return false;
+  return isMountedMcpToolPermissionRequest(request, mountedServers);
 }
-function serialized(value) {
-  if (typeof value === "string")
-    return value;
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return "";
-  }
+function isScheduledPrompt(item, agentId) {
+  if (item.type !== "system" || !item.mentionIds.includes(agentId))
+    return false;
+  if (item.systemEvent?.kind)
+    return item.systemEvent.kind === "schedule-ran";
+  return item.systemEvent?.verb === SCHEDULE_RAN_VERB;
 }
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+function inboxItemAuthorName(item, agentId, names) {
+  if (isScheduledPrompt(item, agentId))
+    return SCHEDULE_SCHEDULER_NAME;
+  const subject = item.systemEvent?.subject;
+  if (item.type === "system" && subject?.name)
+    return subject.name;
+  return names.get(item.authorId) ?? item.authorId.slice(0, 12);
 }
-function clampBytes(value, maxBytes) {
-  const clean4 = value.trim();
-  if (Buffer.byteLength(clean4) <= maxBytes)
-    return clean4;
-  const suffix = "\n\u2026[truncated]";
-  const allowed = maxBytes - Buffer.byteLength(suffix);
-  return `${Buffer.from(clean4).subarray(0, Math.max(0, allowed)).toString("utf8")}${suffix}`;
+function inboxItemPromptBody(item, agentId) {
+  return isScheduledPrompt(item, agentId) ? item.systemEvent?.consequence ?? item.body : item.body;
 }
-function outputExcerpt(value) {
-  const redacted = redactToolDetail(serialized(value));
-  if (!redacted.trim())
-    return void 0;
-  if (/\b(?:git[- ]credential|credential[- ]helper)\b/i.test(redacted)) {
-    return "Credential-helper output omitted.";
+function pendingGrantToolCall(call) {
+  if (!/(?:^|[._:/-])request_grant$/i.test(call.title ?? ""))
+    return false;
+  return /pending, card posted/i.test(typeof call.content === "string" ? call.content : JSON.stringify(call.content ?? ""));
+}
+function roomMentionDirectory(roster, selfId) {
+  const rows = [];
+  for (const member of roster.members) {
+    if (member.identityId === selfId)
+      continue;
+    const handle = member.handle?.trim().replace(/^@/, "");
+    const name = member.name?.trim() ?? "";
+    const alias = handle || name;
+    if (!alias)
+      continue;
+    const kind = member.kind === "agent" ? "agent" : "person";
+    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
   }
-  const lines = redacted.split(/\r?\n/).map((line) => line.trimEnd());
-  if (lines.length <= 8)
-    return clampBytes(lines.join("\n"), TOOL_OUTPUT_MAX_BYTES);
-  return clampBytes([...lines.slice(0, 4), "\u2026[output omitted]\u2026", ...lines.slice(-4)].join("\n"), TOOL_OUTPUT_MAX_BYTES);
+  if (!rows.length)
+    return "";
+  return [
+    "Room members, and the exact spelling that tags each one:",
+    "An exact agent tag assigns that agent work; use it only when you are asking that agent to act.",
+    ...rows,
+    "Write a tag exactly as spelled here. An @name spelled any other way is plain text: it reaches nobody, and nobody is told it was meant for them. Never invent a handle, shorten one, or copy an @name out of the conversation \u2014 old messages carry spellings that no longer exist."
+  ].join("\n");
 }
-function filePaths(value, worktreePath) {
-  const paths = /* @__PURE__ */ new Set();
-  const visit = (candidate, key) => {
-    if (paths.size >= TOOL_PATH_LIMIT || candidate === null || candidate === void 0)
-      return;
-    if (typeof candidate === "string") {
-      if (key && /(?:^|_)(?:path|file|filename|target)$/i.test(key)) {
-        const path = candidate.startsWith(`${worktreePath}/`) ? candidate.slice(worktreePath.length + 1) : candidate;
-        if (path && path.length <= 512)
-          paths.add(redactToolDetail(path));
-      }
-      return;
-    }
-    if (Array.isArray(candidate)) {
-      candidate.forEach((entry) => visit(entry));
-      return;
-    }
-    const object = record(candidate);
-    if (object)
-      Object.entries(object).forEach(([entryKey, entry]) => visit(entry, entryKey));
-  };
-  visit(value);
-  return [...paths];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function resultStatus(call) {
-  const content = record(call.content) ?? (typeof call.content === "string" ? (() => {
-    try {
-      return record(JSON.parse(call.content));
-    } catch {
-      return void 0;
-    }
-  })() : void 0);
-  const exitCode = content?.exitCode ?? content?.exit_code ?? content?.code;
-  if (typeof exitCode === "number" && Number.isFinite(exitCode))
-    return `exit ${exitCode}`;
-  if (content?.ok === true || content?.success === true)
-    return "ok";
-  if (content?.ok === false || content?.success === false)
-    return "error";
-  return /(?:failed|error|denied)/i.test(call.status ?? "") ? "error" : "ok";
-}
-function toolArguments(call) {
-  const raw = record(call.rawInput);
-  const command = typeof call.rawInput === "string" ? call.rawInput : typeof raw?.command === "string" ? raw.command : typeof raw?.cmd === "string" ? raw.cmd : void 0;
-  if (command)
-    return { command: clampBytes(redactToolDetail(command), TOOL_ARGUMENT_MAX_BYTES) };
-  const input = serialized(call.rawInput);
-  return input ? { input: clampBytes(redactToolDetail(input), TOOL_ARGUMENT_MAX_BYTES) } : {};
-}
-function toolCallKey(call, index) {
-  return call.id ?? `tool-${index}`;
-}
-function toolCallSettled(call) {
-  return /^(?:completed|complete|failed|error|succeeded|success|passed|done)$/i.test(call.status ?? "");
-}
-function isSuccessfulCommit(call) {
-  if (/failed|error|denied/i.test(call.status ?? ""))
-    return false;
-  return /\bgit\s+commit\b|\bcommit(?:ted)?\s+(?:changes|files?)\b/i.test(`${call.title ?? ""} ${serialized(call.rawInput)}`);
-}
-async function cornerToolActivity(call, worktreePath, requestedBy) {
-  const operation = oneLine(call.kind ?? "") || "tool";
-  let title = oneLine(redactToolDetail(call.title ?? "")) || `${operation} tool`;
-  if (isSuccessfulCommit(call)) {
-    try {
-      const shown = await execFileAsync3("git", ["-C", worktreePath, "show", "--format=%s", "--name-only", "--no-renames", "HEAD"], { maxBuffer: 1024 * 1024 });
-      const lines = shown.stdout.split(/\r?\n/);
-      const subject = oneLine(lines.shift() ?? "commit");
-      const files = new Set(lines.map(oneLine).filter(Boolean));
-      title = `committed ${files.size} files: ${subject}`;
-    } catch {
+function agentReplyMentionIds(text2, roster, authorId) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const member of roster.members) {
+    if (member.identityId === authorId)
+      continue;
+    const rawAliases = member.kind === "agent" ? [member.handle] : [member.name, member.handle, member.soul?.name];
+    for (const raw of rawAliases) {
+      const display = raw?.trim().replace(/^@/, "");
+      if (!display)
+        continue;
+      const key = display.toLocaleLowerCase();
+      const entry = aliases.get(key) ?? { display, ids: /* @__PURE__ */ new Set() };
+      entry.ids.add(member.identityId);
+      aliases.set(key, entry);
     }
   }
-  const paths = filePaths([call.rawInput, call.content, call.locations], worktreePath);
-  const argumentsSummary = toolArguments(call);
-  const output = outputExcerpt(call.content);
-  return {
-    kind: "tool",
-    title: title.slice(0, 240),
-    operation: operation.slice(0, 80),
-    status: resultStatus(call),
-    ...argumentsSummary,
-    ...output ? { output } : {},
-    ...requestedBy ? { requestedBy } : {},
-    ...paths.length ? { files: paths.map((path) => ({ path })) } : {}
-  };
-}
-var CORNER_CLOSE_POLL_BASE_MS = 12e3;
-function cornerClosePollMs(random = Math.random) {
-  return CORNER_CLOSE_POLL_BASE_MS + Math.floor(random() * 3e3);
+  for (const member of roster.members) {
+    if (member.identityId === authorId || member.kind === "agent" || !member.handle)
+      continue;
+    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
+    const canonical = aliases.get(handle);
+    const legacy = `a_${handle}`;
+    if (canonical && !aliases.has(legacy))
+      aliases.set(legacy, { ...canonical, display: legacy });
+  }
+  const mentioned = [];
+  for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
+    if (ids.size !== 1)
+      continue;
+    const pattern = new RegExp(`(^|[\\s([{])@${escapeRegExp(display)}(?=$|[\\s.,!?;:)\\]}])`, "iu");
+    if (!pattern.test(text2))
+      continue;
+    const identityId = [...ids][0];
+    if (!mentioned.includes(identityId))
+      mentioned.push(identityId);
+  }
+  return mentioned;
 }
-var MonolithCornerTurnLoop = class {
+var MonolithRoomTurnLoop = class {
   options;
+  commandContext;
   agent;
-  reconciliationRequested = true;
   wakeIntake;
   /** Called by the daemon's one slow workspace reconciliation sweep. */
   requestReconciliation() {
-    this.reconciliationRequested = true;
     this.wakeIntake?.();
     this.wakeIntake = void 0;
   }
@@ -20787,67 +20892,110 @@ var MonolithCornerTurnLoop = class {
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
   sessionFingerprint;
-  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
-  warmTranscript = new WarmTranscript();
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
   pinnedProviders = [];
-  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
-  modelTakesImages;
   /** The one provider re-pinned after an empty completion, until the session ends. */
   pinnedProviderOverride;
-  turnIdentityInstructions = "";
   busy = false;
-  forcedStop = false;
-  activityTail = Promise.resolve();
+  turnInstructionPrefix = "";
+  activeTurn;
+  queuedTurns = [];
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
-  /** The session's TMPDIR, where a granted command's script argument may also live. */
+  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
+  modelTakesImages;
+  /** The session's TMPDIR: writable to a granted command in a Room, as it is to the harness (C94). */
   sessionScratchDir;
-  /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
-  currentTurn;
+  /** The `agent-home.ts` overlay this session writes into; a Room grant keeps it. */
+  sessionStateDirs = [];
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
+  /** Local copies already delivered this session, by message id, so transcript renders reuse them. */
+  deliveredAttachments = /* @__PURE__ */ new Map();
+  /** Names from the latest roster read, for ledger bylines the runner writes. */
+  memberNames = /* @__PURE__ */ new Map();
+  /** The request id of the turn that paused on a grant card, until its decision arrives. */
+  pausedOnGrantRequestId;
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
-  memberNames = /* @__PURE__ */ new Map();
-  /** Agent identities in this Workspace, so a mention can be told from a human's. */
-  agentMembers = /* @__PURE__ */ new Set();
-  /** The member agent that answered in this corner last (`carriesCorner`). */
-  carrier;
-  /** The last server check state that started a turn; the same state never starts another. */
-  lastChecksState;
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
-    options.grantRunner?.register(options.cornerId, {
+    this.commandContext = new CommandExecutionContext(options.config.agentHomeRoot);
+    this.options = { ...options, api: this.commandContext.bind(options.api) };
+    options.grantRunner?.register(options.roomId, {
       workspaceId: options.workspaceId,
-      cwd: options.worktreePath,
-      // A corner is the surface with `run-host-command`: its worktree becomes a
-      // branch and a pull request, and host work belongs here, next to the
-      // transcript that explains it. A granted command runs unwrapped (C94).
-      writePolicy: () => ({
-        surface: "corner",
-        ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {}
-      }),
-      turn: () => this.currentTurn
+      cwd: options.cwd,
+      // A top-level Room keeps its read-only promise for grants too: the runner
+      // wraps the command in this Room's own mount table (C94).
+      writePolicy: () => this.grantWritePolicy(),
+      turn: () => {
+        const turn = this.currentTurnForRunner();
+        return turn ? { ...turn, generationId: this.commandContext.generationId } : void 0;
+      }
     });
   }
   isBusy() {
     return this.busy;
   }
-  currentPrincipalCanDrive(_workspaceId, _principalId) {
-    return Promise.resolve(true);
+  /** The turn a `request_grant` paused, if any (cleared when its decision resumes it). */
+  pausedGrantRequestId() {
+    return this.pausedOnGrantRequestId;
   }
-  refreshPersonaForSoulUpdate() {
-    return this.options.scheduler.suspend(this.options.cornerId);
+  /**
+   * What the grant runner may write here: the session's own scratch and home
+   * overlay and nothing else, enforced by the same read-only mount table the
+   * harness runs under. With no usable bwrap there is no way to keep that
+   * promise, so the policy carries no path and the runner refuses the run
+   * rather than widening the boundary.
+   */
+  grantWritePolicy() {
+    return {
+      surface: "room",
+      ...this.options.config.bwrapPath ? { bwrapPath: this.options.config.bwrapPath } : {},
+      ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {},
+      ...this.sessionStateDirs.length ? { harnessStateDirs: this.sessionStateDirs } : {},
+      maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, this.options.config.operatorHome ?? homedir6())
+    };
+  }
+  /**
+   * One turn's stopwatch. It is created for every turn — measuring is cheap —
+   * and only WRITES when the daemon configured a runtime directory to write
+   * into, so a standalone or test Body stays silent.
+   */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "room",
+      agentId: this.agent.publicKey,
+      roomId: this.options.roomId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+    });
+  }
+  currentTurnForRunner() {
+    const active = this.activeTurn;
+    if (!active)
+      return void 0;
+    return { requestId: active.item.id, requester: this.requesterOf(active.item.authorId) };
+  }
+  requesterOf(authorId) {
+    const name = this.memberNames.get(authorId);
+    return { pubkey: authorId, ...name ? { name } : {} };
+  }
+  async refreshPersonaForSoulUpdate() {
+    await this.options.scheduler.suspend(this.options.roomId);
   }
   async prepareForForcedUpdateRestart() {
-    this.forcedStop = true;
   }
   async forceRecoverRoom() {
     if (this.client && this.sessionId)
       this.client.sessionCancel(this.sessionId);
-    await this.options.scheduler.forceSuspend(this.options.cornerId);
+    await this.options.scheduler.forceSuspend(this.options.roomId);
   }
   async roster() {
     const roster = await this.options.api.execute("getWorkspaceRoster", {
@@ -20855,11 +21003,36 @@ var MonolithCornerTurnLoop = class {
       workspaceId: this.options.workspaceId
     });
     this.memberNames = new Map(roster.members.map((member) => [member.identityId, member.name]));
-    this.agentMembers = new Set(roster.members.filter((member) => member.kind === "agent").map((member) => member.identityId));
     return roster;
   }
   /**
-   * Drop this corner's live harness process. The next activation starts cold.
+   * Whether a picture actually reaches the model this session. Both halves
+   * have to hold (C87): the harness must advertise `promptCapabilities.image`,
+   * AND — when the pin knows the model's modalities — the model must take
+   * images. `undefined` modalities mean the question was never settled, and
+   * the harness answer stands alone as before.
+   */
+  acceptsImages() {
+    if (!(this.client?.canPromptWithImages() ?? false))
+      return false;
+    return this.modelTakesImages ?? true;
+  }
+  /** Download a message's attachments into the session scratch directory once. */
+  async deliver(item) {
+    if (!item.attachments.length || !this.attachmentDir)
+      return [];
+    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);
+    this.deliveredAttachments.set(item.id, withoutImageData(delivered));
+    return delivered;
+  }
+  repositoryState() {
+    return this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId });
+  }
+  /**
+   * Drop this Room's live harness process. The next activation starts cold.
    * A rotation is a fact about one live session, so the pin goes with it.
    */
   async discardSession() {
@@ -20871,8 +21044,14 @@ var MonolithCornerTurnLoop = class {
     if (client?.isAlive)
       await client.stop();
   }
-  /** See `MonolithRoomTurnLoop.sessionIsCurrent`: retention never keeps a
-   *  session whose persona or model pin the operator has since changed. */
+  /**
+   * Whether the retained session still matches the agent's server-side
+   * configuration. Retention (C104) is a saving only while what it keeps is
+   * still current, and a session's persona and model pin are fixed when it
+   * opens: they cannot be corrected in place, so a changed one has to cost a
+   * respawn. The check is one round trip — the roster half of which the turn
+   * was going to fetch anyway — against a cold spawn measured in seconds.
+   */
   async sessionIsCurrent() {
     return await this.currentSessionFingerprint() === this.sessionFingerprint;
   }
@@ -20880,7 +21059,7 @@ var MonolithCornerTurnLoop = class {
     const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.cornerId
+        roomId: this.options.roomId
       }),
       this.roster()
     ]);
@@ -20896,12 +21075,13 @@ var MonolithCornerTurnLoop = class {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
     trace?.noteActivation("cold");
-    const [configuration, roster] = await Promise.all([
+    const [configuration, roster, repositoryState] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.cornerId
+        roomId: this.options.roomId
       }),
-      this.roster()
+      this.roster(),
+      this.repositoryState()
     ]);
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const fingerprint = sessionConfigFingerprint({
@@ -20910,7 +21090,8 @@ var MonolithCornerTurnLoop = class {
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name
     });
-    await mkdir9(this.options.worktreePath, { recursive: true });
+    const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
+    await mkdir10(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,
@@ -20927,26 +21108,7 @@ var MonolithCornerTurnLoop = class {
       })
     }) : {};
     const command = this.options.config.agentCommand ?? this.options.config.agentBinary;
-    const repository = this.options.repository;
-    let githubEnv = repository ? { GH_TOKEN: repository.githubToken, GITHUB_TOKEN: repository.githubToken } : {};
-    if (repository && this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
-      const gitBinary = (await execFileAsync3("which", ["git"])).stdout.trim();
-      const ghBinary = await execFileAsync3("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
-      githubEnv = await installCornerGitHubWrappers({
-        root: this.options.config.agentHomeRoot,
-        runtimeConfigPath: this.options.config.runtimeConfigPath,
-        roomId: this.options.parentRoomId,
-        cliEntrypoint: process.argv[1],
-        gitBinary,
-        ...ghBinary ? { ghBinary } : {},
-        inheritedPath: this.options.config.agentEnv.PATH ?? process.env.PATH
-      });
-    }
-    const agentEnv = {
-      ...this.options.config.agentEnv,
-      ...homeOverlay,
-      ...githubEnv
-    };
+    const agentEnv = { ...this.options.config.agentEnv, ...homeOverlay };
     this.agentEnv = agentEnv;
     const agentArgs = agentArgsWithModelSelection({
       kind: this.options.config.agentKind,
@@ -20955,21 +21117,19 @@ var MonolithCornerTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir6();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join5(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join6(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
+    this.sessionStateDirs = stateDirs;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir9(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir10(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
     if (attachScratchRoot)
-      await mkdir9(attachScratchRoot, { recursive: true });
+      await mkdir10(attachScratchRoot, { recursive: true });
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
-        mode: "edit",
-        cwd: this.options.worktreePath,
-        worktreePath: this.options.worktreePath,
-        ...repository ? { gitCommonDir: repository.gitCommonDir } : {},
-        protectedPaths: [this.options.runtime.supervisorRoot],
+        mode: "readonly",
+        cwd: this.options.cwd,
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
         ...tmpDir ? { tmpDir } : {},
@@ -20979,81 +21139,64 @@ var MonolithCornerTurnLoop = class {
       command,
       args: agentArgs
     });
+    const servers = [
+      readOnlyMcpServer(this.options.config, this.options.cwd),
+      beelineAgentMcpServer(this.options.config, this.options.api, {
+        roomId: this.options.roomId,
+        workspaceId: this.options.workspaceId,
+        attachRoot: this.options.cwd,
+        // The whole per-session overlay, not an enumerated subset: the agent
+        // never picks where a harness writes a file it generates (grok's own
+        // images dir, say), so anything inside the overlay it could possibly
+        // have written must be attachable, whatever subdirectory that is.
+        attachScratchRoot,
+        turnContextPath: this.commandContext.path,
+        directMessage,
+        ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
+      })
+    ];
+    await installPiMcpBridge({
+      agentCommand: command,
+      piHome: agentEnv.PI_CODING_AGENT_DIR,
+      servers
+    });
+    const mountedServers = servers.map((server) => server.name);
     const clientOptions = {
       agentCommand: spawnCommand.command,
       agentArgs: spawnCommand.args,
       agentEnv,
-      agentCwd: this.options.worktreePath,
+      agentCwd: this.options.cwd,
       agentLabel: command,
-      autoApprovePermissions: true,
-      permissionHandler: () => Promise.resolve("allow")
+      // `bwrapPath` is set only when `detectBwrapSandbox` passed its self-test
+      // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
+      osSandbox: Boolean(this.options.config.bwrapPath),
+      autoApprovePermissions: false,
+      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
     };
     this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
     await this.client.start();
-    const servers = [
-      ...repository ? [
-        {
-          name: "buzz-dev-mcp",
-          command: this.options.config.mcpBinary,
-          args: [],
-          // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
-          // This token is minted for this exact corner and is also the credential
-          // helper's password source, so its shell commands need the same scope as
-          // the corner harness without inheriting any host credentials.
-          env: [
-            { name: "GH_TOKEN", value: repository.githubToken },
-            { name: "GITHUB_TOKEN", value: repository.githubToken }
-          ]
-        }
-      ] : [],
-      beelineAgentMcpServer(this.options.config, this.options.api, {
-        roomId: this.options.parentRoomId,
-        workspaceId: this.options.workspaceId,
-        cornerId: this.options.cornerId,
-        attachRoot: this.options.worktreePath,
-        // The whole per-session overlay, not an enumerated subset: see
-        // `monolith-room-turn.ts`'s matching comment.
-        attachScratchRoot,
-        ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
-      })
-    ];
-    await installPiMcpBridge({
-      agentCommand: command,
-      piHome: agentEnv.PI_CODING_AGENT_DIR,
-      servers
-    });
     const persona = configuration.soul ?? self?.soul;
-    const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
+    const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
-      ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
+      ...persona?.instructions ? [
+        `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
+        `Soul instructions: ${persona.instructions}`,
+        "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
+        "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
+      ] : [],
       SOUL_HOUSE_RULE
     ].join("\n");
-    this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
+    const repositoryInfo = repositoryState.resolution === "repository" && repositoryState.key ? {
+      name: repositoryState.key,
+      branch: repositoryState.targetBranch || "main"
+    } : void 0;
+    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo, directMessage);
+    this.turnInstructionPrefix = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions, capabilityContext.compatibilityTurnPrefix].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
-      cwd: this.options.worktreePath,
+      cwd: this.options.cwd,
       mcpServers: servers,
-      mode: "edit",
-      systemPrompt: [
-        identityInstructions,
-        personaInstructions,
-        ...repository ? [
-          `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
-          "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
-          `This corner is shared: any of its member agents may be addressed in it and work on ${repository.featureBranch}. Run git pull --rebase origin ${repository.featureBranch} before you push, and never force-push it.`,
-          "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
-          'Never merge because local tests pass or because gh reports passing checks. On a later turn triggered by a server-posted checks-passed note, call beeline-agent pr_checks_status. Merge only when it returns checks="passed", held=false, and approvalPending=false.',
-          "Merge the PR yourself only after the checks-passed event shows every check green; if any check failed or is still running, say exactly which and stop - never merge red.",
-          "If any human in this corner says hold or do not merge, do not merge until a later human explicitly resumes it.",
-          "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
-          'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
-          "A human approval in the app asks the server to merge. When approval is pending, wait for the server close request instead of racing it with gh. If checks passed, no hold exists, and no approval is pending, merge the pull request yourself with gh.",
-          "Never push directly to the target branch. Never merge a different pull request."
-        ] : [
-          "This is a chat-only corner with no repository or GitHub workflow.",
-          "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
-          "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
-        ]
-      ].filter(Boolean).join("\n\n")
+      mode: "readonly",
+      systemPrompt: [identityInstructions, personaInstructions, capabilityContext.sessionPrompt].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
     this.sessionFingerprint = fingerprint;
@@ -21063,7 +21206,12 @@ var MonolithCornerTurnLoop = class {
     }
     return opened.sessionId;
   }
-  /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
+  /**
+   * The scheduler seam, and the only place that can see the boundary between
+   * waiting for a slot and spawning a harness: `queue-wait` closes the instant
+   * `activate()` is called, and `cold` vs `warm` is decided by whether this
+   * Room already holds a live ACP client.
+   */
   lifecycle(trace) {
     return {
       activate: async () => {
@@ -21082,12 +21230,6 @@ var MonolithCornerTurnLoop = class {
       suspend: () => this.discardSession()
     };
   }
-  /** A picture reaches the model only if the harness AND the model take one (C87). */
-  acceptsImages() {
-    if (!(this.client?.canPromptWithImages() ?? false))
-      return false;
-    return this.modelTakesImages ?? true;
-  }
   /** The pinned providers a failure reason should name for this session. */
   servingProviders() {
     return this.pinnedProviderOverride ? [this.pinnedProviderOverride] : this.pinnedProviders;
@@ -21106,7 +21248,8 @@ var MonolithCornerTurnLoop = class {
   /**
    * Re-pin the session to the next provider in the OpenRouter order and open a
    * fresh session on it, so the retry of an empty completion is served — and
-   * named — by exactly one provider (C92).
+   * named — by exactly one provider. Undefined when the pin has nowhere left
+   * to go.
    */
   async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
@@ -21123,523 +21266,418 @@ var MonolithCornerTurnLoop = class {
     await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
-  /** One turn's stopwatch; writes only when the daemon configured a trace directory. */
-  beginTurnTrace(requestId) {
-    const directory = this.options.config.turnTraceDir;
-    if (directory)
-      this.turnTraceSink ??= new TurnTraceFile(directory);
-    return new TurnTrace({
-      surface: "corner",
-      agentId: this.agent.publicKey,
-      roomId: this.options.cornerId,
-      requestId,
-      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+  startPrompt(item) {
+    const active = {
+      item,
+      steers: [],
+      steerTail: Promise.resolve(),
+      resumeRequested: false,
+      cancelled: false,
+      phase: "prompting",
+      promise: Promise.resolve()
+    };
+    this.activeTurn = active;
+    active.promise = this.prompt(active).catch((error) => {
+      this.options.health.failure(1e3);
+      console.error(`[thin-core] monolith Room ${this.options.roomId} turn failed:`, error);
+    }).finally(() => {
+      if (this.activeTurn === active) {
+        this.activeTurn = void 0;
+        this.wakeIntake?.();
+        this.wakeIntake = void 0;
+      }
     });
   }
-  async prompt(requestId, trigger, attachments = [], requestedById, restates) {
-    const { api, cornerId } = this.options;
-    const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
-    const requester = requestedById ? {
-      pubkey: requestedById,
-      ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
-    } : void 0;
-    this.currentTurn = { requestId, ...requester ? { requester } : {} };
-    this.carrier = this.agent.publicKey;
-    const trace = this.beginTurnTrace(requestId);
+  /**
+   * Obey a stop the requester already made a fact.
+   *
+   * A stop names ONE request id and touches only the turn that answers it. The
+   * turn in flight is cancelled at the harness and marked so its own run
+   * publishes nothing; a turn still queued is simply dropped, since starting
+   * work the person has already withdrawn is worse than never starting it.
+   * A stop for neither is ignored — it belongs to a turn that ended between
+   * the press and the delivery, and the server's own receipt already said so.
+   */
+  stopTurn(requestId) {
+    for (let index = this.queuedTurns.length - 1; index >= 0; index -= 1)
+      if (this.queuedTurns[index].id === requestId)
+        this.queuedTurns.splice(index, 1);
+    const active = this.activeTurn;
+    if (!active || active.item.id !== requestId)
+      return;
+    active.cancelled = true;
+    if (this.client && this.sessionId)
+      this.client.sessionCancel(this.sessionId);
+  }
+  async prompt(active) {
+    const { item } = active;
+    const api = this.options.api;
+    this.busy = true;
+    const trace = this.beginTurnTrace(item.id);
     try {
+      if (!this.memberNames.has(item.authorId))
+        await this.roster().catch(() => void 0);
       await withTurnReceiptHeartbeat(api, {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
-        generationId: `${this.agent.publicKey}:${cornerId}`
-      }, () => {
+        roomId: this.options.roomId,
+        requestId: item.id,
+        generationId: this.commandContext.generationId
+      }, async () => {
+        await api.execute("postAgentActivity", {
+          agentId: this.agent.publicKey,
+          roomId: this.options.roomId,
+          requestId: item.id,
+          activity: [
+            {
+              kind: "thinking",
+              title: "Working",
+              status: "in_progress",
+              requestedBy: this.requesterOf(item.authorId)
+            }
+          ]
+        });
         trace.noteScheduler("queue", this.options.scheduler.snapshot());
         trace.start("queue-wait");
-        return this.options.scheduler.run(cornerId, this.lifecycle(trace), async () => {
+        await this.options.scheduler.run(this.options.roomId, this.lifecycle(trace), async () => {
           trace.end("queue-wait");
           trace.noteScheduler("admission", this.options.scheduler.snapshot());
-          if (this.forcedStop)
-            throw new Error("corner turn stopped for daemon handoff");
-          this.busy = true;
-          await this.syncBranch();
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
-            api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
+            api.execute("getRoomConversation", { roomId: this.options.roomId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join5(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            this.deliver(item)
           ]));
           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;
-          if (requestedBy)
-            this.currentTurn = { requestId, requester: requestedBy };
-          const transcriptRows = conversation.items.slice(-120).map((message) => ({
+          const transcriptRows = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => ({
             id: message.id,
-            line: `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`
+            line: roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())
           }));
+          const grantDecision = this.commandContext.current?.action === "resume";
+          const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
+          if (grantDecision)
+            this.pausedOnGrantRequestId = void 0;
           const buildPrompt = () => [
-            this.turnIdentityInstructions,
-            `Corner objective:
-${this.options.objective}`,
-            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
+            this.turnInstructionPrefix,
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
+            `Newest message from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
+            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
+            grantDecision ? [
+              "This is the answer to your grant request; your paused work resumes now.",
+              "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
+              "If it was declined, try another way or say plainly what you cannot do."
+            ].join(" ") : "",
+            roomMentionDirectory(roster, this.agent.publicKey),
             [
-              `Newest trigger:
-${trigger}`,
-              ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
-            ].join("\n"),
-            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
-            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
+              "Write only the substantive Room message you want the human to read.",
+              "Do not repeat or paraphrase these instructions.",
+              "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
+              MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
+            ].join(" ")
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
             api,
             agentId: this.agent.publicKey,
-            roomId: cornerId,
-            requestId,
-            label: `corner ${cornerId}`
+            roomId: this.options.roomId,
+            requestId: item.id,
+            label: `monolith Room ${this.options.roomId}`
           });
-          const publishedToolCalls = /* @__PURE__ */ new Set();
-          const publishToolCalls = (calls, settledOnly) => {
-            calls.forEach((call, index) => {
-              const key = toolCallKey(call, index);
-              if (publishedToolCalls.has(key) || settledOnly && !toolCallSettled(call))
-                return;
-              publishedToolCalls.add(key);
-              this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
-                const activity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
-                await api.execute("postAgentActivity", {
-                  agentId: this.agent.publicKey,
-                  roomId: cornerId,
-                  requestId,
-                  activity: [activity]
-                });
-              }).then(() => void 0).catch((error) => {
-                publishedToolCalls.delete(key);
-                console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
-              });
-            });
-          };
           const runPrompt = async () => {
-            stream.beginRun();
-            trace.promptSent();
-            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full) => {
-              trace.firstModelOutput();
-              stream.onChunk(delta, full);
-            }, void 0, (calls) => {
-              trace.toolCalls(calls);
-              publishToolCalls(calls, true);
-            });
-          };
-          let result = await runPrompt();
-          trace.promptSettled();
-          let explained = await this.explainEmpty(result);
-          if (explained && !restates && shouldRetryEmptyTurn(explained)) {
-            const silent = this.servingProviders();
-            const next = await this.repinNextProvider(trace, explained.reason);
-            if (next) {
-              console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
-              result = await runPrompt();
-              trace.promptSettled();
-              explained = await this.explainEmpty(result);
-            }
-          }
-          await this.activityTail;
-          publishToolCalls(result.toolCalls, false);
-          for (const call of result.toolCalls) {
-            const failure = toolCallFailureLine(call);
-            if (failure)
-              console.warn(`[thin-core] corner ${cornerId} ${failure}`);
-          }
-          await this.activityTail;
-          stream.close();
-          let reply = durableReplyText(result.agentText);
+            let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
+            let result2;
+            for (; ; ) {
+              let promptError;
+              try {
+                stream.beginRun();
+                trace.promptSent();
+                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
+                  trace.firstModelOutput();
+                  stream.onChunk(delta, full);
+                }, void 0, (calls) => trace.toolCalls(calls));
+              } catch (error) {
+                promptError = error;
+              }
+              const settledSteerTail = active.steerTail;
+              await settledSteerTail;
+              if (settledSteerTail !== active.steerTail)
+                continue;
+              if (!active.resumeRequested) {
+                if (promptError)
+                  throw promptError;
+                break;
+              }
+              active.resumeRequested = false;
+              nextPrompt = [
+                "The previous run was cancelled because its harness could not accept every live steer.",
+                "Resume the same turn. Keep the original request and everything that happened before it was cancelled.",
+                "Human messages that arrived after the original request, in transcript order:",
+                ...active.steers.map((steerItem) => roomMessagePrompt(steerItem.authorId.slice(0, 12), steerItem.body, steerItem.attachments, this.deliveredAttachments.get(steerItem.id), this.acceptsImages())),
+                "Continue now and answer the updated request without erasing the earlier context."
+              ].join("\n\n");
+            }
+            return result2;
+          };
+          let result = await runPrompt();
+          trace.promptSettled();
+          let explained = await this.explainEmpty(result);
+          if (explained && shouldRetryEmptyTurn(explained)) {
+            const silent = this.servingProviders();
+            const next = await this.repinNextProvider(trace, explained.reason);
+            if (next) {
+              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);
+            }
+          }
+          if (active.cancelled) {
+            stream.close();
+            throw new TurnStoppedError("turn stopped by the requester");
+          }
+          active.phase = "finishing";
+          if (result.toolCalls.some((call) => pendingGrantToolCall(call))) {
+            this.pausedOnGrantRequestId = item.id;
+            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} paused on a grant card`);
+          } 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))
+              this.options.onCornerOpened?.();
+          }
+          for (const call of result?.toolCalls ?? []) {
+            const failure = toolCallFailureLine(call);
+            if (failure) {
+              console.warn(`[thin-core] monolith Room ${this.options.roomId} ${failure}`);
+            }
+          }
+          stream.close();
+          let reply = durableReplyText(result.agentText);
           if (!reply && explained) {
             reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
-            if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
+            if (!reply) {
               throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
             }
-            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
+            console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
           }
-          await trace.measure("publish", () => stream.settle(spoken(reply)));
-        }, { priority: "interactive", roomKey: cornerId });
-      }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
+          if (openCornerCall && !isFailedToolCall(openCornerCall)) {
+            reply = stripCornerOpenEcho(reply);
+          }
+          const mentionIds = reply ? agentReplyMentionIds(reply, roster, this.agent.publicKey) : [];
+          await trace.measure("publish", () => stream.settle(reply, reply ? {
+            triggerMessageId: item.id,
+            mentionIds
+          } : {}));
+        }, { priority: "interactive", roomKey: this.options.roomId });
+      }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
+        roomId: this.options.roomId,
+        requestId: item.id,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${cornerId}`
+        generationId: this.commandContext.generationId
       });
       await trace.finish("complete");
     } catch (error) {
+      if (error instanceof TurnStoppedError || active.cancelled) {
+        console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} stopped by the requester`);
+        await trace.finish("cancelled");
+        return;
+      }
       const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
+        roomId: this.options.roomId,
+        requestId: item.id,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${cornerId}`,
+        generationId: this.commandContext.generationId,
         reason
       });
       await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
-      this.currentTurn = void 0;
     }
   }
-  /** Whether this agent opened the corner. A corner with no recorded opener
-   *  behaves exactly as it did before members could carry it. */
-  isOpener() {
-    return !this.options.openedBy || this.options.openedBy === this.agent.publicKey;
-  }
-  /**
-   * Whether this agent is the one carrying the corner right now.
-   *
-   * Every member agent polls the corner, but its lifecycle — a server check
-   * note, a close request answered with work — is ONE fact and must start ONE
-   * turn, not one per member (the "one check turn per changed server state"
-   * rule). The carrier is whoever answered in the corner last, which is the
-   * opener until a human hands the work to someone else.
-   */
-  carriesCorner() {
-    return (this.carrier ?? this.options.openedBy ?? this.agent.publicKey) === this.agent.publicKey;
-  }
-  /** Notes an agent's durable message as the corner changing hands. */
-  noteCarrier(authorId) {
-    if (this.agentMembers.has(authorId))
-      this.carrier = authorId;
-  }
-  /**
-   * Whether a human message in this corner is addressed to THIS agent.
-   *
-   * A corner now runs like a Room — every member agent polls it — so an
-   * unrouted message would start one turn per member on one branch. A mention
-   * routes: the mentioned agent answers and nobody else. A message that names
-   * no agent at all keeps the old behaviour and falls to the opener, which is
-   * every single-agent corner ever opened.
-   */
-  async addressesThisAgent(item) {
-    if (item.mentionIds.includes(this.agent.publicKey))
-      return true;
-    if (!item.mentionIds.length)
-      return this.carriesCorner();
-    await this.roster().catch(() => void 0);
-    return item.mentionIds.some((id) => this.agentMembers.has(id)) ? false : this.carriesCorner();
-  }
-  /**
-   * Bring this worktree onto the corner's branch as GitHub currently has it,
-   * before any work is done on top of it.
-   *
-   * The branch is the shared artifact: another member agent may have pushed to
-   * it since this helper last looked, and a first touch of a corner this
-   * helper did not open starts from whatever `room-runtime.ts` restored. A
-   * divergence this cannot rebase away is raised, not pushed over — the turn
-   * fails with that sentence and the server inscribes it in the corner.
-   */
-  async syncBranch() {
-    const repository = this.options.repository;
-    if (!repository)
-      return;
-    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => repository.githubToken);
-    await syncCornerBranch({
-      worktreePath: this.options.worktreePath,
-      featureBranch: repository.featureBranch,
-      env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token, GIT_TERMINAL_PROMPT: "0" }
-    });
-  }
-  /** The server's check state for this head, or the notes' own verdict when the server carries none. */
-  async checksState(notes) {
-    try {
-      const restore = await this.options.api.execute("getCornerRestoreState", {
-        cornerId: this.options.cornerId
-      });
-      const fromServer = checksStateFromLifecycle(restore.lifecycle);
-      if (fromServer)
-        return fromServer;
-    } catch (error) {
-      console.error(`[thin-core] corner ${this.options.cornerId} check state read failed:`, error);
-    }
-    return notes.some((note) => completedCheckNote(note) === "failed") ? "failing" : "passing";
-  }
   async run() {
-    const { api, cornerId, signal } = this.options;
-    const activation = await api.execute("getRoomInbox", {
-      roomId: cornerId,
-      startAtLatest: true
-    });
-    let cursor3 = activation.cursor;
-    const processedInboxIds = /* @__PURE__ */ new Set();
-    const pushedInbox = [];
-    let pendingPushedCursor;
-    let liveConnected = false;
-    const rewindSupported = Array.isArray(activation.rewindIds);
-    for (const id of activation.rewindIds ?? [])
-      processedInboxIds.add(id);
-    const stopLive = api.liveSubscribe?.(cornerId, cursor3, (items, pushedCursor) => {
-      pushedInbox.push(...items);
-      pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-      this.wakeIntake?.();
-      this.wakeIntake = void 0;
-    }, (connected, capabilities) => {
-      liveConnected = connected && capabilities?.pushIntake === true;
-      this.wakeIntake?.();
-      this.wakeIntake = void 0;
-    }, {
-      ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
-      ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
-      available: !this.options.config.modelUnavailable
-    });
-    const history = await api.execute("getRoomConversation", { roomId: cornerId, limit: 200 });
-    await this.roster().catch(() => void 0);
-    for (const item of history.items)
-      if (item.type === "message")
-        this.noteCarrier(item.authorId);
-    const durableAgentReplies = history.items.filter((item) => item.type === "message" && item.authorId === this.agent.publicKey && item.body.trim() !== this.options.objective.trim());
-    if (durableAgentReplies.length === 0 && this.isOpener()) {
-      await this.prompt(history.items.find((item) => item.requestId)?.requestId ?? cornerId.replaceAll("-", ""), this.options.objective);
-    }
+    const { api, roomId, signal } = this.options;
     try {
-      let pollWithoutWait = false;
-      while (!signal?.aborted) {
-        try {
-          const pollNow = pushedInbox.length > 0 || !liveConnected || this.reconciliationRequested;
-          const inbox = !pollNow ? { items: [], cursor: void 0, closeRequested: false } : await api.execute("getCornerCloseRequests", {
-            cornerId,
-            ...cursor3 ? { after: cursor3 } : {},
-            ...rewindSupported ? { rewind: true } : {}
-          });
-          if (pollNow) {
-            this.reconciliationRequested = false;
-          }
-          if (inbox.closeRequested) {
-            await this.options.onCloseRequested();
-            return;
-          }
-          const checkNotes = [];
-          const delivered = [...pushedInbox.splice(0), ...inbox.items];
-          for (const item of delivered) {
-            if (processedInboxIds.has(item.id))
-              continue;
-            processedInboxIds.add(item.id);
-            while (processedInboxIds.size > 1e4)
-              processedInboxIds.delete(processedInboxIds.values().next().value);
-            if (item.type === "message") {
-              this.noteCarrier(item.authorId);
-              if (item.authorId === this.agent.publicKey)
-                continue;
-              if (!await this.addressesThisAgent(item))
-                continue;
-              const authority = await api.execute("getRoomAuthority", {
-                roomId: cornerId,
-                principalId: item.authorId
-              });
-              if (!authority.member || authority.principalKind !== "human")
-                continue;
-              await this.prompt(item.id, item.body, item.attachments, item.authorId);
-              pollWithoutWait = true;
-              continue;
-            }
-            const grantDecision = item.type === "system" && item.mentionIds.includes(this.agent.publicKey) && parseGrantDecisionLine(item.body) !== void 0;
-            if (grantDecision) {
-              await this.prompt(item.id, `${item.body}
-This answers your grant request; resume the paused work. If approved and it is a command grant, run it with run_granted_command and the exact argv; if declined, try another way or say what you cannot do.`, [], item.authorId);
-              pollWithoutWait = true;
-              continue;
-            }
-            if (isCheckStartNote(item)) {
-              this.lastChecksState = void 0;
-              continue;
-            }
-            if (completedCheckNote(item))
-              checkNotes.push(item);
-          }
-          if (checkNotes.length && this.carriesCorner()) {
-            const state = await this.checksState(checkNotes);
-            if (state && state !== "pending" && state !== this.lastChecksState) {
-              this.lastChecksState = state;
-              const lines = checkNotes.map((note) => note.body);
-              await this.prompt(checkNotes[checkNotes.length - 1].id, lines.join("\n"), [], void 0, lines);
-              pollWithoutWait = true;
-            }
-          }
-          cursor3 = laterInboxCursor(cursor3, laterInboxCursor(inbox.cursor, pendingPushedCursor));
-          pendingPushedCursor = void 0;
-          api.updateLiveCursor?.(cornerId, cursor3);
-          if (pollNow)
-            this.options.onPoll();
-          await Promise.race([
-            wait(pollWithoutWait ? 0 : liveConnected ? 2147483647 : this.options.pollMs ?? cornerClosePollMs(), signal),
-            pushedInbox.length ? Promise.resolve() : new Promise((resolve30) => {
-              this.wakeIntake = resolve30;
-            })
-          ]);
-          pollWithoutWait = false;
-        } catch (error) {
-          if (signal?.aborted)
-            break;
-          this.options.onFailure(1e3);
-          console.error(`[thin-core] corner ${cornerId} turn loop failed:`, error);
-          await wait(1e3, signal);
+      await runServerCommandIntake({
+        api,
+        roomId,
+        agentId: this.agent.publicKey,
+        context: this.commandContext,
+        signal,
+        pollMs: this.options.pollMs,
+        presence: {
+          ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
+          ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
+          available: !this.options.config.modelUnavailable
+        },
+        onWake: (wake) => {
+          this.wakeIntake = wake;
+        },
+        onPoll: () => this.options.health.poll(),
+        onError: (error) => console.error("[thin-core] Room command failed", error),
+        stop: (requestId) => this.stopTurn(requestId),
+        run: async (command) => {
+          const item = {
+            ...command.source,
+            id: command.turnRequestId,
+            body: command.action === "resume" ? `Resume the paused turn. The server supplied this grant decision: ${command.source.body}` : command.source.body
+          };
+          this.startPrompt(item);
+          await this.activeTurn?.promise;
         }
-      }
+      });
     } finally {
-      stopLive?.();
-      this.wakeIntake = void 0;
-      this.options.grantRunner?.unregister(cornerId);
-      await this.options.scheduler.suspend(cornerId);
+      this.options.grantRunner?.unregister(roomId);
+      await this.options.scheduler.suspend(roomId);
     }
   }
 };
-async function wait(ms, signal) {
-  if (signal?.aborted)
-    return;
-  await new Promise((resolveWait) => {
-    const done = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolveWait();
-    };
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-  });
+function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsImages = true) {
+  const message = body.trim() || "(shared attachments)";
+  const rendered = author ? `${author}: ${message}` : message;
+  return [rendered, ...attachmentPromptLines(attachments, delivered, harnessAcceptsImages)].join("\n");
 }
 
-// apps/body/dist/monolith-room-turn.js
-import { mkdir as mkdir10 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { join as join6 } 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
-function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
-  if (isSquireMcpPermissionRequest(request))
-    return false;
-  return isMountedMcpToolPermissionRequest(request, mountedServers);
-}
-function roomPrincipalMayAddressAgent(authority, humanPermitted) {
-  if (!authority.member)
-    return false;
-  if (authority.principalKind === "agent")
-    return true;
-  if (authority.principalKind !== "human")
-    return false;
-  return authority.mayAddressAgent ?? humanPermitted;
+// apps/body/dist/monolith-corner-turn.js
+var execFileAsync3 = promisify3(execFile4);
+var TOOL_ARGUMENT_MAX_BYTES = 1200;
+var TOOL_OUTPUT_MAX_BYTES = 3200;
+var TOOL_PATH_LIMIT = 12;
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
 }
-function isScheduledPrompt(item, agentId) {
-  if (item.type !== "system" || !item.mentionIds.includes(agentId))
-    return false;
-  if (item.systemEvent?.kind)
-    return item.systemEvent.kind === "schedule-ran";
-  return item.systemEvent?.verb === SCHEDULE_RAN_VERB;
+function serialized(value) {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
 }
-function inboxItemAuthorName(item, agentId, names) {
-  if (isScheduledPrompt(item, agentId))
-    return SCHEDULE_SCHEDULER_NAME;
-  const subject = item.systemEvent?.subject;
-  if (item.type === "system" && subject?.name)
-    return subject.name;
-  return names.get(item.authorId) ?? item.authorId.slice(0, 12);
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function inboxItemPromptBody(item, agentId) {
-  return isScheduledPrompt(item, agentId) ? item.systemEvent?.consequence ?? item.body : item.body;
+function clampBytes(value, maxBytes) {
+  const clean4 = value.trim();
+  if (Buffer.byteLength(clean4) <= maxBytes)
+    return clean4;
+  const suffix = "\n\u2026[truncated]";
+  const allowed = maxBytes - Buffer.byteLength(suffix);
+  return `${Buffer.from(clean4).subarray(0, Math.max(0, allowed)).toString("utf8")}${suffix}`;
 }
-function isSubscribedEvent(item, agentId) {
-  const kind = item.systemEvent?.kind;
-  return item.type === "system" && kind !== void 0 && !isResumeKind(kind) && item.mentionIds.includes(agentId);
+function outputExcerpt(value) {
+  const redacted = redactToolDetail(serialized(value));
+  if (!redacted.trim())
+    return void 0;
+  if (/\b(?:git[- ]credential|credential[- ]helper)\b/i.test(redacted)) {
+    return "Credential-helper output omitted.";
+  }
+  const lines = redacted.split(/\r?\n/).map((line) => line.trimEnd());
+  if (lines.length <= 8)
+    return clampBytes(lines.join("\n"), TOOL_OUTPUT_MAX_BYTES);
+  return clampBytes([...lines.slice(0, 4), "\u2026[output omitted]\u2026", ...lines.slice(-4)].join("\n"), TOOL_OUTPUT_MAX_BYTES);
 }
-function inboxItemSkipsSenderPolicy(item, agentId) {
-  if (isGrantDecisionLine(item, agentId))
-    return true;
-  if (item.type !== "system" || !item.mentionIds.includes(agentId))
-    return false;
-  const kind = item.systemEvent?.kind;
-  return kind === void 0 ? isScheduledPrompt(item, agentId) : isServerEventKind(kind);
+function filePaths(value, worktreePath) {
+  const paths = /* @__PURE__ */ new Set();
+  const visit = (candidate, key) => {
+    if (paths.size >= TOOL_PATH_LIMIT || candidate === null || candidate === void 0)
+      return;
+    if (typeof candidate === "string") {
+      if (key && /(?:^|_)(?:path|file|filename|target)$/i.test(key)) {
+        const path = candidate.startsWith(`${worktreePath}/`) ? candidate.slice(worktreePath.length + 1) : candidate;
+        if (path && path.length <= 512)
+          paths.add(redactToolDetail(path));
+      }
+      return;
+    }
+    if (Array.isArray(candidate)) {
+      candidate.forEach((entry) => visit(entry));
+      return;
+    }
+    const object = record(candidate);
+    if (object)
+      Object.entries(object).forEach(([entryKey, entry]) => visit(entry, entryKey));
+  };
+  visit(value);
+  return [...paths];
 }
-function isGrantDecisionLine(item, agentId) {
-  return item.type === "system" && item.mentionIds.includes(agentId) && parseGrantDecisionLine(item.body) !== void 0;
+function resultStatus(call) {
+  const content = record(call.content) ?? (typeof call.content === "string" ? (() => {
+    try {
+      return record(JSON.parse(call.content));
+    } catch {
+      return void 0;
+    }
+  })() : void 0);
+  const exitCode = content?.exitCode ?? content?.exit_code ?? content?.code;
+  if (typeof exitCode === "number" && Number.isFinite(exitCode))
+    return `exit ${exitCode}`;
+  if (content?.ok === true || content?.success === true)
+    return "ok";
+  if (content?.ok === false || content?.success === false)
+    return "error";
+  return /(?:failed|error|denied)/i.test(call.status ?? "") ? "error" : "ok";
 }
-function inboxItemTriggersTurn(item, agentId) {
-  if (item.authorId === agentId)
-    return false;
-  if (!item.mentionIds.includes(agentId))
-    return false;
-  return item.type === "message" || isSubscribedEvent(item, agentId) || isScheduledPrompt(item, agentId) || isGrantDecisionLine(item, agentId);
+function toolArguments(call) {
+  const raw = record(call.rawInput);
+  const command = typeof call.rawInput === "string" ? call.rawInput : typeof raw?.command === "string" ? raw.command : typeof raw?.cmd === "string" ? raw.cmd : void 0;
+  if (command)
+    return { command: clampBytes(redactToolDetail(command), TOOL_ARGUMENT_MAX_BYTES) };
+  const input = serialized(call.rawInput);
+  return input ? { input: clampBytes(redactToolDetail(input), TOOL_ARGUMENT_MAX_BYTES) } : {};
 }
-function pendingGrantToolCall(call) {
-  if (!/(?:^|[._:/-])request_grant$/i.test(call.title ?? ""))
-    return false;
-  return /pending, card posted/i.test(typeof call.content === "string" ? call.content : JSON.stringify(call.content ?? ""));
+function toolCallKey(call, index) {
+  return call.id ? `id-${createHash4("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
 }
-function roomMentionDirectory(roster, selfId) {
-  const rows = [];
-  for (const member of roster.members) {
-    if (member.identityId === selfId)
-      continue;
-    const handle = member.handle?.trim().replace(/^@/, "");
-    const name = member.name?.trim() ?? "";
-    const alias = handle || name;
-    if (!alias)
-      continue;
-    const kind = member.kind === "agent" ? "agent" : "person";
-    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
-  }
-  if (!rows.length)
-    return "";
-  return [
-    "Room members, and the exact spelling that tags each one:",
-    ...rows,
-    "Write a tag exactly as spelled here. An @name spelled any other way is plain text: it reaches nobody, and nobody is told it was meant for them. Never invent a handle, shorten one, or copy an @name out of the conversation \u2014 old messages carry spellings that no longer exist."
-  ].join("\n");
+function toolCallSettled(call) {
+  if (call.resultReceived)
+    return true;
+  return /^(?:completed|complete|failed|error|succeeded|success|passed|done)$/i.test(call.status ?? "");
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isSuccessfulCommit(call) {
+  if (/failed|error|denied/i.test(call.status ?? ""))
+    return false;
+  return /\bgit\s+commit\b|\bcommit(?:ted)?\s+(?:changes|files?)\b/i.test(`${call.title ?? ""} ${serialized(call.rawInput)}`);
 }
-function agentReplyMentionIds(text2, roster, authorId) {
-  const aliases = /* @__PURE__ */ new Map();
-  for (const member of roster.members) {
-    if (member.identityId === authorId)
-      continue;
-    for (const raw of [member.name, member.handle, member.soul?.name]) {
-      const display = raw?.trim().replace(/^@/, "");
-      if (!display)
-        continue;
-      const key = display.toLocaleLowerCase();
-      const entry = aliases.get(key) ?? { display, ids: /* @__PURE__ */ new Set() };
-      entry.ids.add(member.identityId);
-      aliases.set(key, entry);
+async function cornerToolActivity(call, worktreePath, requestedBy) {
+  const operation = oneLine(call.kind ?? "") || "tool";
+  let title = oneLine(redactToolDetail(call.title ?? "")) || `${operation} tool`;
+  if (isSuccessfulCommit(call)) {
+    try {
+      const shown = await execFileAsync3("git", ["-C", worktreePath, "show", "--format=%s", "--name-only", "--no-renames", "HEAD"], { maxBuffer: 1024 * 1024 });
+      const lines = shown.stdout.split(/\r?\n/);
+      const subject = oneLine(lines.shift() ?? "commit");
+      const files = new Set(lines.map(oneLine).filter(Boolean));
+      title = `committed ${files.size} files: ${subject}`;
+    } catch {
     }
   }
-  for (const member of roster.members) {
-    if (member.identityId === authorId || !member.handle)
-      continue;
-    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
-    const canonical = aliases.get(handle);
-    const legacy = `a_${handle}`;
-    if (canonical && !aliases.has(legacy))
-      aliases.set(legacy, { ...canonical, display: legacy });
-  }
-  const mentioned = [];
-  for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
-    if (ids.size !== 1)
-      continue;
-    const pattern = new RegExp(`(^|[\\s([{])@${escapeRegExp(display)}(?=$|[\\s.,!?;:)\\]}])`, "iu");
-    if (!pattern.test(text2))
-      continue;
-    const identityId = [...ids][0];
-    if (!mentioned.includes(identityId))
-      mentioned.push(identityId);
-  }
-  return mentioned;
+  const paths = filePaths([call.rawInput, call.content, call.locations], worktreePath);
+  const argumentsSummary = toolArguments(call);
+  const output = outputExcerpt(call.content);
+  return {
+    kind: "tool",
+    title: title.slice(0, 240),
+    operation: operation.slice(0, 80),
+    status: resultStatus(call),
+    ...argumentsSummary,
+    ...output ? { output } : {},
+    ...requestedBy ? { requestedBy } : {},
+    ...paths.length ? { files: paths.map((path) => ({ path })) } : {}
+  };
 }
-var MonolithRoomTurnLoop = class {
+var MonolithCornerTurnLoop = class {
   options;
+  commandContext;
   agent;
-  reconciliationRequested = true;
   wakeIntake;
   /** Called by the daemon's one slow workspace reconciliation sweep. */
   requestReconciliation() {
-    this.reconciliationRequested = true;
     this.wakeIntake?.();
     this.wakeIntake = void 0;
   }
@@ -21647,108 +21685,88 @@ var MonolithRoomTurnLoop = class {
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
   sessionFingerprint;
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
   pinnedProviders = [];
+  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
+  modelTakesImages;
   /** The one provider re-pinned after an empty completion, until the session ends. */
   pinnedProviderOverride;
+  turnIdentityInstructions = "";
   busy = false;
-  turnInstructionPrefix = "";
-  activeTurn;
-  queuedTurns = [];
+  forcedStop = false;
+  activityTail = Promise.resolve();
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
-  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
-  modelTakesImages;
-  /** The session's TMPDIR: writable to a granted command in a Room, as it is to the harness (C94). */
+  /** The session's TMPDIR, where a granted command's script argument may also live. */
   sessionScratchDir;
-  /** The `agent-home.ts` overlay this session writes into; a Room grant keeps it. */
-  sessionStateDirs = [];
-  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
-  warmTranscript = new WarmTranscript();
-  /** Local copies already delivered this session, by message id, so transcript renders reuse them. */
-  deliveredAttachments = /* @__PURE__ */ new Map();
-  /** Names from the latest roster read, for ledger bylines the runner writes. */
-  memberNames = /* @__PURE__ */ new Map();
-  /** The request id of the turn that paused on a grant card, until its decision arrives. */
-  pausedOnGrantRequestId;
+  /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
+  currentTurn;
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
+  memberNames = /* @__PURE__ */ new Map();
+  /** Agent identities in this Workspace, so a mention can be told from a human's. */
+  /** Per-sender continuity, shared in shape with top-level Room intake. */
+  /** The member agent that owns corner-wide lifecycle facts such as checks. */
+  /** The last server check state that started a turn; the same state never starts another. */
+  /**
+   * Request ids the requester has stopped. A corner's intake is blocked while
+   * its turn runs, so a stop is recorded from the live-push callback and read
+   * back here; ids that never matched a running turn are harmless and bounded
+   * by the same replay window the inbox already de-duplicates over.
+   */
+  stoppedTurns = /* @__PURE__ */ new Set();
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
-    options.grantRunner?.register(options.roomId, {
+    this.commandContext = new CommandExecutionContext(options.config.agentHomeRoot);
+    this.options = { ...options, api: this.commandContext.bind(options.api) };
+    options.grantRunner?.register(options.cornerId, {
       workspaceId: options.workspaceId,
-      cwd: options.cwd,
-      // A top-level Room keeps its read-only promise for grants too: the runner
-      // wraps the command in this Room's own mount table (C94).
-      writePolicy: () => this.grantWritePolicy(),
-      turn: () => this.currentTurnForRunner()
+      cwd: options.worktreePath,
+      // A corner is the surface with `run-host-command`: its worktree becomes a
+      // branch and a pull request, and host work belongs here, next to the
+      // transcript that explains it. A granted command runs unwrapped (C94).
+      writePolicy: () => ({
+        surface: "corner",
+        ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {}
+      }),
+      turn: () => this.currentTurn ? { ...this.currentTurn, generationId: this.commandContext.generationId } : void 0
     });
   }
   isBusy() {
     return this.busy;
   }
-  /** The turn a `request_grant` paused, if any (cleared when its decision resumes it). */
-  pausedGrantRequestId() {
-    return this.pausedOnGrantRequestId;
-  }
-  /**
-   * What the grant runner may write here: the session's own scratch and home
-   * overlay and nothing else, enforced by the same read-only mount table the
-   * harness runs under. With no usable bwrap there is no way to keep that
-   * promise, so the policy carries no path and the runner refuses the run
-   * rather than widening the boundary.
-   */
-  grantWritePolicy() {
-    return {
-      surface: "room",
-      ...this.options.config.bwrapPath ? { bwrapPath: this.options.config.bwrapPath } : {},
-      ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {},
-      ...this.sessionStateDirs.length ? { harnessStateDirs: this.sessionStateDirs } : {},
-      maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, this.options.config.operatorHome ?? homedir7())
-    };
-  }
-  /**
-   * One turn's stopwatch. It is created for every turn — measuring is cheap —
-   * and only WRITES when the daemon configured a runtime directory to write
-   * into, so a standalone or test Body stays silent.
-   */
-  beginTurnTrace(requestId) {
-    const directory = this.options.config.turnTraceDir;
-    if (directory)
-      this.turnTraceSink ??= new TurnTraceFile(directory);
-    return new TurnTrace({
-      surface: "room",
-      agentId: this.agent.publicKey,
-      roomId: this.options.roomId,
-      requestId,
-      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
-    });
-  }
-  currentTurnForRunner() {
-    const active = this.activeTurn;
-    if (!active)
-      return void 0;
-    return { requestId: active.item.id, requester: this.requesterOf(active.item.authorId) };
-  }
-  requesterOf(authorId) {
-    const name = this.memberNames.get(authorId);
-    return { pubkey: authorId, ...name ? { name } : {} };
-  }
-  currentPrincipalCanDrive(_workspaceId, principalId) {
-    return Promise.resolve(isSenderPermitted(this.options.config.accessPolicy ?? LEGACY_ACCESS_POLICY, principalId, this.options.config.accessOwnerPubkey, this.options.config.accessAllowlist));
-  }
-  async refreshPersonaForSoulUpdate() {
-    await this.options.scheduler.suspend(this.options.roomId);
+  refreshPersonaForSoulUpdate() {
+    return this.options.scheduler.suspend(this.options.cornerId);
   }
   async prepareForForcedUpdateRestart() {
+    this.forcedStop = true;
   }
   async forceRecoverRoom() {
     if (this.client && this.sessionId)
       this.client.sessionCancel(this.sessionId);
-    await this.options.scheduler.forceSuspend(this.options.roomId);
+    await this.options.scheduler.forceSuspend(this.options.cornerId);
+  }
+  /**
+   * Obey a stop the requester already made a fact.
+   *
+   * The id is remembered whether or not it names the turn in flight: a stop for
+   * work not yet started must still keep that work from starting, and one for a
+   * turn that has already ended is simply never read again. Only the session
+   * actually running the stopped turn is cancelled.
+   */
+  stopTurn(requestId) {
+    this.stoppedTurns.add(requestId);
+    while (this.stoppedTurns.size > 500)
+      this.stoppedTurns.delete(this.stoppedTurns.values().next().value);
+    if (this.currentTurn?.requestId !== requestId)
+      return;
+    if (this.client && this.sessionId)
+      this.client.sessionCancel(this.sessionId);
   }
   async roster() {
     const roster = await this.options.api.execute("getWorkspaceRoster", {
@@ -21759,33 +21777,7 @@ var MonolithRoomTurnLoop = class {
     return roster;
   }
   /**
-   * Whether a picture actually reaches the model this session. Both halves
-   * have to hold (C87): the harness must advertise `promptCapabilities.image`,
-   * AND — when the pin knows the model's modalities — the model must take
-   * images. `undefined` modalities mean the question was never settled, and
-   * the harness answer stands alone as before.
-   */
-  acceptsImages() {
-    if (!(this.client?.canPromptWithImages() ?? false))
-      return false;
-    return this.modelTakesImages ?? true;
-  }
-  /** Download a message's attachments into the session scratch directory once. */
-  async deliver(item) {
-    if (!item.attachments.length || !this.attachmentDir)
-      return [];
-    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);
-    this.deliveredAttachments.set(item.id, withoutImageData(delivered));
-    return delivered;
-  }
-  repositoryState() {
-    return this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId });
-  }
-  /**
-   * Drop this Room's live harness process. The next activation starts cold.
+   * Drop this corner's live harness process. The next activation starts cold.
    * A rotation is a fact about one live session, so the pin goes with it.
    */
   async discardSession() {
@@ -21797,14 +21789,8 @@ var MonolithRoomTurnLoop = class {
     if (client?.isAlive)
       await client.stop();
   }
-  /**
-   * Whether the retained session still matches the agent's server-side
-   * configuration. Retention (C104) is a saving only while what it keeps is
-   * still current, and a session's persona and model pin are fixed when it
-   * opens: they cannot be corrected in place, so a changed one has to cost a
-   * respawn. The check is one round trip — the roster half of which the turn
-   * was going to fetch anyway — against a cold spawn measured in seconds.
-   */
+  /** See `MonolithRoomTurnLoop.sessionIsCurrent`: retention never keeps a
+   *  session whose persona or model pin the operator has since changed. */
   async sessionIsCurrent() {
     return await this.currentSessionFingerprint() === this.sessionFingerprint;
   }
@@ -21812,7 +21798,7 @@ var MonolithRoomTurnLoop = class {
     const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId
+        roomId: this.options.cornerId
       }),
       this.roster()
     ]);
@@ -21828,13 +21814,12 @@ var MonolithRoomTurnLoop = class {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
     trace?.noteActivation("cold");
-    const [configuration, roster, repositoryState] = await Promise.all([
+    const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId
+        roomId: this.options.cornerId
       }),
-      this.roster(),
-      this.repositoryState()
+      this.roster()
     ]);
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const fingerprint = sessionConfigFingerprint({
@@ -21843,8 +21828,7 @@ var MonolithRoomTurnLoop = class {
       soul: configuration.soul ?? self?.soul,
       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.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,
@@ -21861,7 +21845,26 @@ var MonolithRoomTurnLoop = class {
       })
     }) : {};
     const command = this.options.config.agentCommand ?? this.options.config.agentBinary;
-    const agentEnv = { ...this.options.config.agentEnv, ...homeOverlay };
+    const repository = this.options.repository;
+    let githubEnv = repository ? { GH_TOKEN: repository.githubToken, GITHUB_TOKEN: repository.githubToken } : {};
+    if (repository && this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
+      const gitBinary = (await execFileAsync3("which", ["git"])).stdout.trim();
+      const ghBinary = await execFileAsync3("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
+      githubEnv = await installCornerGitHubWrappers({
+        root: this.options.config.agentHomeRoot,
+        runtimeConfigPath: this.options.config.runtimeConfigPath,
+        roomId: this.options.parentRoomId,
+        cliEntrypoint: process.argv[1],
+        gitBinary,
+        ...ghBinary ? { ghBinary } : {},
+        inheritedPath: this.options.config.agentEnv.PATH ?? process.env.PATH
+      });
+    }
+    const agentEnv = {
+      ...this.options.config.agentEnv,
+      ...homeOverlay,
+      ...githubEnv
+    };
     this.agentEnv = agentEnv;
     const agentArgs = agentArgsWithModelSelection({
       kind: this.options.config.agentKind,
@@ -21870,19 +21873,21 @@ var MonolithRoomTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir7();
     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: {
-        mode: "readonly",
-        cwd: this.options.cwd,
+        mode: "edit",
+        cwd: this.options.worktreePath,
+        worktreePath: this.options.worktreePath,
+        ...repository ? { gitCommonDir: repository.gitCommonDir } : {},
+        protectedPaths: [this.options.runtime.supervisorRoot],
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
         ...tmpDir ? { tmpDir } : {},
@@ -21892,18 +21897,42 @@ var MonolithRoomTurnLoop = class {
       command,
       args: agentArgs
     });
+    const clientOptions = {
+      agentCommand: spawnCommand.command,
+      agentArgs: spawnCommand.args,
+      agentEnv,
+      agentCwd: this.options.worktreePath,
+      agentLabel: command,
+      autoApprovePermissions: true,
+      permissionHandler: () => Promise.resolve("allow")
+    };
+    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
+    await this.client.start();
     const servers = [
-      readOnlyMcpServer(this.options.config, this.options.cwd),
+      ...repository ? [
+        {
+          name: "buzz-dev-mcp",
+          command: this.options.config.mcpBinary,
+          args: [],
+          // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
+          // This token is minted for this exact corner and is also the credential
+          // helper's password source, so its shell commands need the same scope as
+          // the corner harness without inheriting any host credentials.
+          env: [
+            { name: "GH_TOKEN", value: repository.githubToken },
+            { name: "GITHUB_TOKEN", value: repository.githubToken }
+          ]
+        }
+      ] : [],
       beelineAgentMcpServer(this.options.config, this.options.api, {
-        roomId: this.options.roomId,
+        roomId: this.options.parentRoomId,
         workspaceId: this.options.workspaceId,
-        attachRoot: this.options.cwd,
-        // The whole per-session overlay, not an enumerated subset: the agent
-        // never picks where a harness writes a file it generates (grok's own
-        // images dir, say), so anything inside the overlay it could possibly
-        // have written must be attachable, whatever subdirectory that is.
+        cornerId: this.options.cornerId,
+        attachRoot: this.options.worktreePath,
+        // The whole per-session overlay, not an enumerated subset: see
+        // `monolith-room-turn.ts`'s matching comment.
         attachScratchRoot,
-        directMessage,
+        turnContextPath: this.commandContext.path,
         ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
       })
     ];
@@ -21912,43 +21941,38 @@ var MonolithRoomTurnLoop = class {
       piHome: agentEnv.PI_CODING_AGENT_DIR,
       servers
     });
-    const mountedServers = servers.map((server) => server.name);
-    const clientOptions = {
-      agentCommand: spawnCommand.command,
-      agentArgs: spawnCommand.args,
-      agentEnv,
-      agentCwd: this.options.cwd,
-      agentLabel: command,
-      // `bwrapPath` is set only when `detectBwrapSandbox` passed its self-test
-      // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
-      osSandbox: Boolean(this.options.config.bwrapPath),
-      autoApprovePermissions: false,
-      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
-    };
-    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
-    await this.client.start();
     const persona = configuration.soul ?? self?.soul;
-    const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
+    const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
-      ...persona?.instructions ? [
-        `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
-        `Soul instructions: ${persona.instructions}`,
-        "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
-        "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
-      ] : [],
+      ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
       SOUL_HOUSE_RULE
     ].join("\n");
-    const repositoryInfo = repositoryState.resolution === "repository" && repositoryState.key ? {
-      name: repositoryState.key,
-      branch: repositoryState.targetBranch || "main"
-    } : void 0;
-    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo, directMessage);
-    this.turnInstructionPrefix = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions, capabilityContext.compatibilityTurnPrefix].filter(Boolean).join("\n\n");
+    this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
-      cwd: this.options.cwd,
+      cwd: this.options.worktreePath,
       mcpServers: servers,
-      mode: "readonly",
-      systemPrompt: [identityInstructions, personaInstructions, capabilityContext.sessionPrompt].filter(Boolean).join("\n\n")
+      mode: "edit",
+      systemPrompt: [
+        identityInstructions,
+        personaInstructions,
+        ...repository ? [
+          `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
+          "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
+          `This corner is shared: any of its member agents may be addressed in it and work on ${repository.featureBranch}. Run git pull --rebase origin ${repository.featureBranch} before you push, and never force-push it.`,
+          "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
+          'Never merge because local tests pass or because gh reports passing checks. On a later turn triggered by a server-posted checks-passed note, call beeline-agent pr_checks_status. Merge only when it returns checks="passed", held=false, and approvalPending=false.',
+          "Merge the PR yourself only after the checks-passed event shows every check green; if any check failed or is still running, say exactly which and stop - never merge red.",
+          "If any human in this corner says hold or do not merge, do not merge until a later human explicitly resumes it.",
+          "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
+          'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
+          "A human approval in the app asks the server to merge. When approval is pending, wait for the server close request instead of racing it with gh. If checks passed, no hold exists, and no approval is pending, merge the pull request yourself with gh.",
+          "Never push directly to the target branch. Never merge a different pull request."
+        ] : [
+          "This is a chat-only corner with no repository or GitHub workflow.",
+          "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
+          "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
+        ]
+      ].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
     this.sessionFingerprint = fingerprint;
@@ -21958,12 +21982,7 @@ var MonolithRoomTurnLoop = class {
     }
     return opened.sessionId;
   }
-  /**
-   * The scheduler seam, and the only place that can see the boundary between
-   * waiting for a slot and spawning a harness: `queue-wait` closes the instant
-   * `activate()` is called, and `cold` vs `warm` is decided by whether this
-   * Room already holds a live ACP client.
-   */
+  /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
   lifecycle(trace) {
     return {
       activate: async () => {
@@ -21982,6 +22001,12 @@ var MonolithRoomTurnLoop = class {
       suspend: () => this.discardSession()
     };
   }
+  /** A picture reaches the model only if the harness AND the model take one (C87). */
+  acceptsImages() {
+    if (!(this.client?.canPromptWithImages() ?? false))
+      return false;
+    return this.modelTakesImages ?? true;
+  }
   /** The pinned providers a failure reason should name for this session. */
   servingProviders() {
     return this.pinnedProviderOverride ? [this.pinnedProviderOverride] : this.pinnedProviders;
@@ -22000,8 +22025,7 @@ var MonolithRoomTurnLoop = class {
   /**
    * Re-pin the session to the next provider in the OpenRouter order and open a
    * fresh session on it, so the retry of an empty completion is served — and
-   * named — by exactly one provider. Undefined when the pin has nowhere left
-   * to go.
+   * named — by exactly one provider (C92).
    */
   async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
@@ -22018,343 +22042,310 @@ var MonolithRoomTurnLoop = class {
     await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
-  startPrompt(item) {
-    const active = {
-      item,
-      steers: [],
-      steerTail: Promise.resolve(),
-      resumeRequested: false,
-      phase: "prompting",
-      promise: Promise.resolve()
-    };
-    this.activeTurn = active;
-    active.promise = this.prompt(active).catch((error) => {
-      this.options.health.failure(1e3);
-      console.error(`[thin-core] monolith Room ${this.options.roomId} turn failed:`, error);
-    }).finally(() => {
-      if (this.activeTurn === active)
-        this.activeTurn = void 0;
-    });
-  }
-  steer(active, item) {
-    active.steers.push(item);
-    active.steerTail = active.steerTail.catch(() => void 0).then(async () => {
-      try {
-        const [roster, delivered] = await Promise.all([this.roster(), this.deliver(item)]);
-        const author = roster.members.find((member) => member.identityId === item.authorId)?.name ?? item.authorId.slice(0, 12);
-        await this.client.sessionSteer(this.sessionId, [
-          `Human steer received while the current turn is running from ${author}:`,
-          roomMessagePrompt("", item.body, item.attachments, delivered, this.acceptsImages()),
-          "Adjust the current work now. Keep the original request and earlier messages as context."
-        ].join("\n\n"));
-      } catch (error) {
-        active.resumeRequested = true;
-        this.client?.sessionCancel(this.sessionId);
-        console.warn(`[thin-core] monolith Room ${this.options.roomId} live steer unavailable; cancelling and resuming:`, error);
-      }
+  /** One turn's stopwatch; writes only when the daemon configured a trace directory. */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "corner",
+      agentId: this.agent.publicKey,
+      roomId: this.options.cornerId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
     });
   }
-  async prompt(active) {
-    const { item } = active;
-    const api = this.options.api;
-    this.busy = true;
-    const trace = this.beginTurnTrace(item.id);
-    try {
-      if (!this.memberNames.has(item.authorId))
-        await this.roster().catch(() => void 0);
-      await withTurnReceiptHeartbeat(api, {
-        agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
-      }, async () => {
-        await api.execute("postAgentActivity", {
-          agentId: this.agent.publicKey,
-          roomId: this.options.roomId,
-          requestId: item.id,
-          activity: [
-            {
-              kind: "thinking",
-              title: "Working",
-              status: "in_progress",
-              requestedBy: this.requesterOf(item.authorId)
-            }
-          ]
-        });
+  async prompt(requestId, trigger, attachments = [], requestedById, restates) {
+    const { api, cornerId } = this.options;
+    if (this.stoppedTurns.has(requestId))
+      return;
+    const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
+    const requester = requestedById ? {
+      pubkey: requestedById,
+      ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
+    } : void 0;
+    this.currentTurn = { requestId, ...requester ? { requester } : {} };
+    const trace = this.beginTurnTrace(requestId);
+    try {
+      await withTurnReceiptHeartbeat(api, {
+        agentId: this.agent.publicKey,
+        roomId: cornerId,
+        requestId,
+        generationId: this.commandContext.generationId
+      }, () => {
         trace.noteScheduler("queue", this.options.scheduler.snapshot());
         trace.start("queue-wait");
-        await this.options.scheduler.run(this.options.roomId, this.lifecycle(trace), async () => {
+        return this.options.scheduler.run(cornerId, this.lifecycle(trace), async () => {
           trace.end("queue-wait");
           trace.noteScheduler("admission", this.options.scheduler.snapshot());
+          if (this.forcedStop)
+            throw new Error("corner turn stopped for daemon handoff");
+          this.busy = true;
+          await this.syncBranch();
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
-            api.execute("getRoomConversation", { roomId: this.options.roomId, limit: 200 }),
+            api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.deliver(item)
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join7(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
           ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
-          const transcriptRows = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => ({
+          const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
+          if (requestedBy)
+            this.currentTurn = { requestId, requester: requestedBy };
+          const transcriptRows = conversation.items.slice(-120).map((message) => ({
             id: message.id,
-            line: roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())
+            line: `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`
           }));
-          const grantDecision = isGrantDecisionLine(item, this.agent.publicKey);
-          const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
-          if (grantDecision)
-            this.pausedOnGrantRequestId = void 0;
           const buildPrompt = () => [
-            this.turnInstructionPrefix,
-            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
-            `Newest message from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
-            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
-            grantDecision ? [
-              "This is the answer to your grant request; your paused work resumes now.",
-              "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
-              "If it was declined, try another way or say plainly what you cannot do."
-            ].join(" ") : "",
+            this.turnIdentityInstructions,
+            `Corner objective:
+${this.options.objective}`,
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
             roomMentionDirectory(roster, this.agent.publicKey),
             [
-              "Write only the substantive Room message you want the human to read.",
-              "Do not repeat or paraphrase these instructions.",
-              "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
-              MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
-            ].join(" ")
+              `Newest trigger:
+${trigger}`,
+              ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
+            ].join("\n"),
+            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
+            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
             api,
             agentId: this.agent.publicKey,
-            roomId: this.options.roomId,
-            requestId: item.id,
-            label: `monolith Room ${this.options.roomId}`
+            roomId: cornerId,
+            requestId,
+            label: `corner ${cornerId}`
           });
-          const runPrompt = async () => {
-            let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
-            let result2;
-            for (; ; ) {
-              let promptError;
-              try {
-                stream.beginRun();
-                trace.promptSent();
-                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
-                  trace.firstModelOutput();
-                  stream.onChunk(delta, full);
-                }, void 0, (calls) => trace.toolCalls(calls));
-              } catch (error) {
-                promptError = error;
+          let currentNarrationRun = "";
+          let completedNarrationRuns = [];
+          let narrationRunBoundary = 0;
+          const takeInterimNarration = () => {
+            const narration = spoken([...completedNarrationRuns, currentNarrationRun].map((run2) => spoken(durableReplyText(run2))).filter((run2) => run2 && !isPureRetryNarration(run2)).join("\n\n"));
+            narrationRunBoundary += completedNarrationRuns.length;
+            completedNarrationRuns = [];
+            currentNarrationRun = "";
+            return narration;
+          };
+          const publishedToolCalls = /* @__PURE__ */ new Set();
+          const observedToolCalls = /* @__PURE__ */ new Set();
+          const pendingToolNarrations = /* @__PURE__ */ new Map();
+          const pendingToolActivities = /* @__PURE__ */ new Map();
+          let lastNarratedToolCall;
+          let activityAttempt = 0;
+          const publishToolCalls = (calls, settledOnly) => {
+            calls.forEach((call, index) => {
+              const key = `${activityAttempt}:${toolCallKey(call, index)}`;
+              if (settledOnly && !observedToolCalls.has(key)) {
+                observedToolCalls.add(key);
+                const narration2 = takeInterimNarration();
+                pendingToolNarrations.set(key, narration2);
+                if (narration2)
+                  lastNarratedToolCall = key;
               }
-              const settledSteerTail = active.steerTail;
-              await settledSteerTail;
-              if (settledSteerTail !== active.steerTail)
-                continue;
-              if (!active.resumeRequested) {
-                if (promptError)
-                  throw promptError;
-                break;
+              if (settledOnly || publishedToolCalls.has(key) || !toolCallSettled(call))
+                return;
+              publishedToolCalls.add(key);
+              const narration = pendingToolNarrations.get(key) ?? "";
+              this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
+                let activity = pendingToolActivities.get(key);
+                if (!activity) {
+                  const toolActivity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
+                  activity = [
+                    ...narration ? [
+                      {
+                        kind: "output",
+                        title: "Update",
+                        text: narration,
+                        ...requestedBy ? { requestedBy } : {}
+                      }
+                    ] : [],
+                    toolActivity
+                  ];
+                  pendingToolActivities.set(key, activity);
+                }
+                await api.execute("postAgentActivity", {
+                  agentId: this.agent.publicKey,
+                  roomId: cornerId,
+                  requestId,
+                  cornerActivityKey: key,
+                  activity
+                });
+                pendingToolNarrations.delete(key);
+                pendingToolActivities.delete(key);
+              }).then(() => void 0).catch((error) => {
+                publishedToolCalls.delete(key);
+                console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
+              });
+            });
+          };
+          const flushToolCalls = async (calls, finalReply) => {
+            await this.activityTail;
+            if (lastNarratedToolCall && pendingToolNarrations.get(lastNarratedToolCall) === finalReply)
+              pendingToolNarrations.delete(lastNarratedToolCall);
+            publishToolCalls(calls, false);
+            await this.activityTail;
+            publishToolCalls(calls, false);
+            await this.activityTail;
+          };
+          const runPrompt = async () => {
+            activityAttempt += 1;
+            publishedToolCalls.clear();
+            observedToolCalls.clear();
+            pendingToolNarrations.clear();
+            pendingToolActivities.clear();
+            lastNarratedToolCall = void 0;
+            stream.beginRun();
+            completedNarrationRuns = [];
+            narrationRunBoundary = 0;
+            currentNarrationRun = "";
+            trace.promptSent();
+            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full, currentRun, runs) => {
+              trace.firstModelOutput();
+              if (runs) {
+                completedNarrationRuns = runs.slice(narrationRunBoundary);
+                currentNarrationRun = "";
+              } else if (currentRun === void 0)
+                currentNarrationRun += delta;
+              else {
+                if (currentNarrationRun && currentNarrationRun !== currentRun && !currentRun.startsWith(currentNarrationRun))
+                  completedNarrationRuns.push(currentNarrationRun);
+                currentNarrationRun = currentRun;
               }
-              active.resumeRequested = false;
-              nextPrompt = [
-                "The previous run was cancelled because its harness could not accept every live steer.",
-                "Resume the same turn. Keep the original request and everything that happened before it was cancelled.",
-                "Human messages that arrived after the original request, in transcript order:",
-                ...active.steers.map((steerItem) => roomMessagePrompt(steerItem.authorId.slice(0, 12), steerItem.body, steerItem.attachments, this.deliveredAttachments.get(steerItem.id), this.acceptsImages())),
-                "Continue now and answer the updated request without erasing the earlier context."
-              ].join("\n\n");
-            }
-            return result2;
+              stream.onChunk(delta, full);
+            }, void 0, (calls) => {
+              trace.toolCalls(calls);
+              publishToolCalls(calls, true);
+            });
           };
           let result = await runPrompt();
           trace.promptSettled();
           let explained = await this.explainEmpty(result);
-          if (explained && shouldRetryEmptyTurn(explained)) {
+          if (explained && !restates && shouldRetryEmptyTurn(explained)) {
+            await flushToolCalls(result.toolCalls, "");
             const silent = this.servingProviders();
             const next = await this.repinNextProvider(trace, explained.reason);
             if (next) {
-              console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
+              console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
               result = await runPrompt();
               trace.promptSettled();
               explained = await this.explainEmpty(result);
             }
           }
-          active.phase = "finishing";
-          if (result.toolCalls.some((call) => pendingGrantToolCall(call))) {
-            this.pausedOnGrantRequestId = item.id;
-            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} paused on a grant card`);
-          } 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))
-              this.options.onCornerOpened?.();
+          if (this.stoppedTurns.has(requestId)) {
+            stream.close();
+            throw new TurnStoppedError("turn stopped by the requester");
           }
-          for (const call of result?.toolCalls ?? []) {
+          let reply = durableReplyText(result.agentText);
+          if (!reply && explained?.recoveredText)
+            reply = durableReplyText(explained.recoveredText);
+          await flushToolCalls(result.toolCalls, reply);
+          for (const call of result.toolCalls) {
             const failure = toolCallFailureLine(call);
-            if (failure) {
-              console.warn(`[thin-core] monolith Room ${this.options.roomId} ${failure}`);
-            }
+            if (failure)
+              console.warn(`[thin-core] corner ${cornerId} ${failure}`);
           }
           stream.close();
-          let reply = durableReplyText(result.agentText);
           if (!reply && explained) {
-            reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
-            if (!reply) {
+            if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
               throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
             }
-            console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
-          }
-          if (openCornerCall && !isFailedToolCall(openCornerCall)) {
-            reply = stripCornerOpenEcho(reply);
+            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
           }
-          await trace.measure("publish", () => stream.settle(reply, reply ? {
-            triggerMessageId: item.id,
-            mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
+          const durableReply = spoken(reply);
+          const mentionIds = durableReply ? agentReplyMentionIds(durableReply, roster, this.agent.publicKey) : [];
+          await trace.measure("publish", () => stream.settle(durableReply, durableReply ? {
+            ...requestedById ? { triggerMessageId: requestId } : {},
+            mentionIds
           } : {}));
-        }, { priority: "interactive", roomKey: this.options.roomId });
-      }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
+        }, { priority: "interactive", roomKey: cornerId });
+      }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
+        roomId: cornerId,
+        requestId,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
+        generationId: this.commandContext.generationId
       });
       await trace.finish("complete");
     } catch (error) {
+      if (error instanceof TurnStoppedError || this.stoppedTurns.has(requestId)) {
+        console.log(`[thin-core] corner ${cornerId} turn ${requestId} stopped by the requester`);
+        await trace.finish("cancelled");
+        return;
+      }
       const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
+        roomId: cornerId,
+        requestId,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`,
+        generationId: this.commandContext.generationId,
         reason
       });
       await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
+      this.currentTurn = void 0;
     }
   }
+  /**
+   * Bring this worktree onto the corner's branch as GitHub currently has it,
+   * before any work is done on top of it.
+   *
+   * The branch is the shared artifact: another member agent may have pushed to
+   * it since this helper last looked, and a first touch of a corner this
+   * helper did not open starts from whatever `room-runtime.ts` restored. A
+   * divergence this cannot rebase away is raised, not pushed over — the turn
+   * fails with that sentence and the server inscribes it in the corner.
+   */
+  async syncBranch() {
+    const repository = this.options.repository;
+    if (!repository)
+      return;
+    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => repository.githubToken);
+    await syncCornerBranch({
+      worktreePath: this.options.worktreePath,
+      featureBranch: repository.featureBranch,
+      env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token, GIT_TERMINAL_PROMPT: "0" }
+    });
+  }
   async run() {
-    const { api, roomId, signal } = this.options;
-    let cursor3;
-    const processedInboxIds = /* @__PURE__ */ new Set();
-    const pushedInbox = [];
-    let pendingPushedCursor;
-    let liveConnected = false;
-    let stopLive;
+    const { api, cornerId, signal } = this.options;
     try {
-      const activation = await api.execute("getRoomInbox", { roomId, startAtLatest: true });
-      cursor3 = activation.cursor;
-      const rewindSupported = Array.isArray(activation.rewindIds);
-      for (const id of activation.rewindIds ?? [])
-        processedInboxIds.add(id);
-      stopLive = api.liveSubscribe?.(roomId, cursor3, (items, pushedCursor) => {
-        pushedInbox.push(...items);
-        pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-        this.wakeIntake?.();
-        this.wakeIntake = void 0;
-      }, (connected, capabilities) => {
-        liveConnected = connected && capabilities?.pushIntake === true;
-        this.options.health.presence(connected && !this.options.config.modelUnavailable ? "online" : "offline");
-        this.wakeIntake?.();
-        this.wakeIntake = void 0;
-      }, {
-        ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
-        ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
-        available: !this.options.config.modelUnavailable
+      await runServerCommandIntake({
+        api,
+        roomId: cornerId,
+        agentId: this.agent.publicKey,
+        context: this.commandContext,
+        signal,
+        pollMs: this.options.pollMs,
+        presence: {
+          ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
+          ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
+          available: !this.options.config.modelUnavailable
+        },
+        onWake: (wake) => {
+          this.wakeIntake = wake;
+        },
+        onPoll: () => this.options.onPoll(),
+        onError: (error) => console.error("[thin-core] corner command failed", error),
+        stop: (requestId) => this.stopTurn(requestId),
+        closed: async () => {
+          const state = await api.execute("getCornerRestoreState", { cornerId });
+          if (!state.closeRequested)
+            return false;
+          await this.options.onCloseRequested();
+          return true;
+        },
+        run: (command) => this.prompt(command.turnRequestId, command.source.body, command.source.attachments, command.source.authorId, command.reason === "corner_check" ? [command.source.body] : void 0)
       });
-      while (!signal?.aborted) {
-        try {
-          if (!this.activeTurn && this.queuedTurns.length) {
-            this.startPrompt(this.queuedTurns.shift());
-          }
-          const pollNow = pushedInbox.length === 0 && (!liveConnected || this.reconciliationRequested);
-          const inbox = !pollNow ? { items: [], cursor: void 0 } : await api.execute("getRoomInbox", {
-            roomId,
-            ...cursor3 ? { after: cursor3 } : {},
-            ...rewindSupported ? { rewind: true } : {},
-            limit: 200
-          });
-          if (pollNow) {
-            this.reconciliationRequested = false;
-          }
-          const delivered = [...pushedInbox.splice(0), ...inbox.items];
-          for (const item of delivered) {
-            if (processedInboxIds.has(item.id))
-              continue;
-            processedInboxIds.add(item.id);
-            while (processedInboxIds.size > 1e4)
-              processedInboxIds.delete(processedInboxIds.values().next().value);
-            if (!inboxItemTriggersTurn(item, this.agent.publicKey))
-              continue;
-            if (!inboxItemSkipsSenderPolicy(item, this.agent.publicKey)) {
-              const authority = await api.execute("getRoomAuthority", {
-                roomId,
-                principalId: item.authorId
-              });
-              const humanPermitted = authority.principalKind === "human" ? await this.currentPrincipalCanDrive(this.options.workspaceId, item.authorId) : false;
-              if (!roomPrincipalMayAddressAgent(authority, humanPermitted))
-                continue;
-            }
-            const active = this.activeTurn;
-            if (!active)
-              this.startPrompt(item);
-            else if (active.phase === "prompting")
-              this.steer(active, item);
-            else
-              this.queuedTurns.push(item);
-          }
-          cursor3 = laterInboxCursor(cursor3, laterInboxCursor(inbox.cursor, pendingPushedCursor));
-          pendingPushedCursor = void 0;
-          api.updateLiveCursor?.(roomId, cursor3);
-          if (pollNow)
-            this.options.health.poll();
-          if (!pushedInbox.length) {
-            await Promise.race([
-              wait2(liveConnected ? 2147483647 : this.options.pollMs ?? 1e3, signal),
-              new Promise((resolve30) => {
-                this.wakeIntake = resolve30;
-              })
-            ]);
-          }
-        } catch (error) {
-          if (signal?.aborted)
-            break;
-          this.options.health.failure(1e3);
-          console.error(`[thin-core] monolith Room ${roomId} turn loop failed:`, error);
-          await wait2(1e3, signal);
-        }
-      }
     } finally {
-      stopLive?.();
-      this.wakeIntake = void 0;
-      this.options.grantRunner?.unregister(roomId);
-      if (this.activeTurn?.phase === "prompting" && this.client && this.sessionId) {
-        this.client.sessionCancel(this.sessionId);
-      }
-      await this.activeTurn?.promise;
-      await this.options.scheduler.suspend(roomId);
+      this.options.grantRunner?.unregister(cornerId);
+      await this.options.scheduler.suspend(cornerId);
     }
   }
 };
-function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsImages = true) {
-  const message = body.trim() || "(shared attachments)";
-  const rendered = author ? `${author}: ${message}` : message;
-  return [rendered, ...attachmentPromptLines(attachments, delivered, harnessAcceptsImages)].join("\n");
-}
-async function wait2(ms, signal) {
-  if (signal?.aborted)
-    return;
-  await new Promise((resolveWait) => {
-    const done = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolveWait();
-    };
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-  });
-}
 
 // apps/body/dist/session-scheduler.js
 var DEFAULT_PER_ROOM_LIVE_SESSIONS = 10;
@@ -22771,11 +22762,11 @@ function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
 }
 async function materializeCornerWorktree(input) {
   const remote = roomCheckoutRemote(input.remote);
-  const repositoryHash = createHash4("sha256").update(remote).digest("hex").slice(0, 24);
+  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 mkdir11(dirname6(gitCommonDir), { recursive: true, mode: 448 });
-  await mkdir11(dirname6(path), { recursive: true, mode: 448 });
+  await mkdir12(dirname7(gitCommonDir), { recursive: true, mode: 448 });
+  await mkdir12(dirname7(path), { recursive: true, mode: 448 });
   const authEnv = githubGitEnv(input.token);
   if (!existsSync4(resolve19(gitCommonDir, "HEAD"))) {
     await execFileAsync4("git", ["clone", "--bare", remote, gitCommonDir], {
@@ -22962,9 +22953,6 @@ var RoomRuntimeCoordinator = class {
       this.drainDeadlineAt = Math.min(this.drainDeadlineAt ?? Number.POSITIVE_INFINITY, deadlineAt);
     }
   }
-  async currentPrincipalCanDrive(roomId, workspaceId, principalId) {
-    return this.running.get(roomId)?.body.currentPrincipalCanDrive(workspaceId, principalId);
-  }
   async prepareForForcedUpdateRestart() {
     const rooms = [...this.running.values()];
     await Promise.allSettled(rooms.filter((room) => room.body.isBusy()).map((room) => room.body.prepareForForcedUpdateRestart()));
@@ -23049,7 +23037,7 @@ var RoomRuntimeCoordinator = class {
     return this.runtime.rooms.find((room) => room.channelId === roomId);
   }
   roomRoot(roomId) {
-    return this.roomRecord(roomId)?.root ?? resolve19(dirname6(this.configPath), "rooms", roomId);
+    return this.roomRecord(roomId)?.root ?? resolve19(dirname7(this.configPath), "rooms", roomId);
   }
   roomAgentHomeRoot(workspaceRoot, required = false) {
     const flag = process.env.BUZZY_BODY_ROOM_HOME;
@@ -23072,9 +23060,9 @@ var RoomRuntimeCoordinator = class {
       ...this.baseConfig,
       workspaceRoot,
       agentPrivateRoot: resolve19(workspaceRoot, "agent-private"),
-      agentMemoryRoot: resolve19(dirname6(this.configPath), "memory"),
-      openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname6(this.configPath)),
-      turnTraceDir: turnTraceDirectory(dirname6(this.configPath)),
+      agentMemoryRoot: resolve19(dirname7(this.configPath), "memory"),
+      openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname7(this.configPath)),
+      turnTraceDir: turnTraceDirectory(dirname7(this.configPath)),
       ...agentHomeRoot ? { agentHomeRoot } : {}
     };
   }
@@ -23140,9 +23128,9 @@ var RoomRuntimeCoordinator = class {
       return this.roomRoot(roomId);
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
-    const checkoutId = createHash4("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
+    const checkoutId = createHash5("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
     const path = resolve19(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
-    await mkdir11(dirname6(path), { recursive: true, mode: 448 });
+    await mkdir12(dirname7(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"))) {
@@ -23208,7 +23196,7 @@ var RoomRuntimeCoordinator = class {
       }) : void 0;
       const workspacePath = worktree?.path ?? resolve19(this.roomRoot(corner.cornerId), "scratch");
       if (!worktree)
-        await mkdir11(workspacePath, { recursive: true, mode: 448 });
+        await mkdir12(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", {
@@ -23507,9 +23495,9 @@ var ThinDaemonCore = class {
 
 // apps/body/dist/systemd.js
 import { execFile as execFile6 } from "node:child_process";
-import { mkdir as mkdir12, readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname7, resolve as resolve20 } from "node:path";
+import { dirname as dirname8, resolve as resolve20 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile6);
@@ -23580,8 +23568,8 @@ async function installAgentService(publicKey, options = {}) {
   const content = agentServiceUnit();
   const existing = await readFile8(path, "utf8").catch(() => "");
   if (existing !== content) {
-    await mkdir12(dirname7(path), { recursive: true, mode: 448 });
-    await writeFile8(path, content, { mode: 384 });
+    await mkdir13(dirname8(path), { recursive: true, mode: 448 });
+    await writeFile9(path, content, { mode: 384 });
   }
   const run2 = options.run ?? runSystemctl;
   await run2(["daemon-reload"]);
@@ -23661,7 +23649,7 @@ async function retireRemovedAgent(runtime, options = {}) {
 }
 
 // apps/body/dist/start-command.js
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } 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;
@@ -23736,7 +23724,7 @@ async function runStartCommand(args, interactiveUi) {
       continue;
     }
     const spinnerHandle = spinner();
-    spinnerHandle.start(`Starting ${dirname8(path)}\u2026`);
+    spinnerHandle.start(`Starting ${dirname9(path)}\u2026`);
     try {
       await startRuntime(path, spinnerHandle);
       spinnerHandle.stop(import_picocolors.default.green("Started."));
@@ -23752,9 +23740,9 @@ async function runStartCommand(args, interactiveUi) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import { chmod as chmod5, mkdir as mkdir14, readFile as readFile10, unlink as unlink2, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve22 } from "node:path";
+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 { stdin as stdin3, stdout as stdout4 } from "node:process";
 
 // apps/body/dist/clack-support.js
@@ -24328,7 +24316,7 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
-  const avatarSeed = createHash6("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
+  const avatarSeed = createHash7("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
   return jsonRequest(`${baseUrl}/auth/agent/connect`, {
     pairing_code: normalizedPairingCode,
     harness: selection.harness,
@@ -24398,8 +24386,8 @@ function providerEnvironment(selection) {
   };
 }
 async function writePrivateJson(path, value) {
-  await mkdir14(dirname10(path), { recursive: true, mode: 448 });
-  await writeFile10(path, `${JSON.stringify(value, null, 2)}
+  await mkdir15(dirname11(path), { recursive: true, mode: 448 });
+  await writeFile11(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
   await chmod5(path, 384);
 }
@@ -24408,9 +24396,9 @@ async function writeProviderEnv(selection, agentPubkey) {
   if (Object.keys(values).length === 0)
     return void 0;
   const path = resolve22(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
-  await mkdir14(dirname10(path), { recursive: true, mode: 448 });
+  await mkdir15(dirname11(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
-  await writeFile10(path, `${contents}
+  await writeFile11(path, `${contents}
 `, { mode: 384 });
   await chmod5(path, 384);
   return path;
@@ -24566,7 +24554,7 @@ async function runConnectFinishCommand(path) {
     if (model) {
       const decision2 = await resolveOpenRouterRouting({
         model,
-        cacheDir: openRouterRoutingCacheDir(dirname10(connected.configPath)),
+        cacheDir: openRouterRoutingCacheDir(dirname11(connected.configPath)),
         ...apiKey ? { apiKey } : {},
         probeTimeoutMs: 1e4
       });
@@ -24588,12 +24576,12 @@ init_self_update_manifest();
 // apps/body/dist/managed-update.js
 init_self_update();
 import { spawn as spawn6 } from "node:child_process";
-import { mkdir as mkdir16, rm as rm6, stat as stat2, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname12, resolve as resolve24 } from "node:path";
+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";
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir15, readFile as readFile11, rename as rename4, unlink as unlink3, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve23 } from "node:path";
+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";
 var REPORT_INTERVAL_MS = 60 * 60 * 1e3;
 var lastLogged = /* @__PURE__ */ new Map();
 function updateRollbackAlertPath(runtimeDir) {
@@ -24602,8 +24590,8 @@ function updateRollbackAlertPath(runtimeDir) {
 async function writeAlert(runtimeDir, alert) {
   const path = updateRollbackAlertPath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir15(dirname11(path), { recursive: true });
-  await writeFile11(staged, `${JSON.stringify(alert, null, 2)}
+  await mkdir16(dirname12(path), { recursive: true });
+  await writeFile12(staged, `${JSON.stringify(alert, null, 2)}
 `, { mode: 384 });
   await rename4(staged, path);
 }
@@ -24668,11 +24656,11 @@ async function withInstallLock(layout, work, options = {}) {
   const now2 = options.now ?? Date.now;
   const lock = resolve24(layout.releasesRoot, ".state", "install.lock");
   const deadline = now2() + (options.waitMs ?? 1e4);
-  await mkdir16(dirname12(lock), { recursive: true });
+  await mkdir17(dirname13(lock), { recursive: true });
   for (; ; ) {
     try {
-      await mkdir16(lock);
-      await writeFile12(resolve24(lock, "owner"), `${process.pid}
+      await mkdir17(lock);
+      await writeFile13(resolve24(lock, "owner"), `${process.pid}
 ${now2()}
 `, "utf8");
       break;
@@ -25082,7 +25070,7 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
   });
   if (!accepted)
     return false;
-  await writeFile12(resolve24(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
+  await writeFile13(resolve24(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
     readyAt: (options.now ?? Date.now)(),
     loadedRelease,
     functionalProof: options.functionalProof
@@ -25310,8 +25298,8 @@ async function runUpdateCommand(args) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir17, readFile as readFile12, rename as rename5, rm as rm7, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname13, resolve as resolve25 } from "node:path";
+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";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
 function daemonFailurePath(runtimeDir) {
@@ -25331,8 +25319,8 @@ async function readFailureRecord(runtimeDir) {
 async function writeFailureRecord(runtimeDir, record2) {
   const path = daemonFailurePath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir17(dirname13(path), { recursive: true, mode: 448 });
-  await writeFile13(staged, `${JSON.stringify(record2, null, 2)}
+  await mkdir18(dirname14(path), { recursive: true, mode: 448 });
+  await writeFile14(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
   await rename5(staged, path);
 }
@@ -25354,7 +25342,7 @@ async function clearDaemonStartFailures(runtimeDir) {
 }
 
 // apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir18, rm as rm8 } from "node:fs/promises";
+import { mkdir as mkdir19, rm as rm8 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
 import { resolve as resolve26 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
@@ -25400,6 +25388,9 @@ async function probeOutcome(run2) {
     await run2();
     return { kind: "served" };
   } catch (error) {
+    if (error instanceof UpdateFunctionalProbeError && error.reason === "sandbox-unavailable") {
+      return { kind: "sandbox-unavailable", reason: error.message };
+    }
     if (error instanceof UpdateFunctionalProbeError && error.providerRefusal) {
       return { kind: "refused", ...error.providerRefusal };
     }
@@ -25412,6 +25403,8 @@ function describeCurrentReleaseOutcome(outcome) {
       return "the current release answered";
     case "refused":
       return `the current release got a different refusal (${outcome.reason})`;
+    case "sandbox-unavailable":
+      return `the current release has the same unavailable sandbox (${outcome.reason})`;
     case "unavailable":
       return `the current release could not be compared (${outcome.reason})`;
   }
@@ -25423,13 +25416,33 @@ async function runUpdateFunctionalProbe(input) {
     throw new UpdateFunctionalProbeError("model-unavailable", input.config.modelUnavailable.detail);
   }
   if (input.sandboxRequired && !input.config.bwrapPath) {
-    throw new UpdateFunctionalProbeError("sandbox-unavailable", "the configured bubblewrap boundary did not pass its startup self-test");
+    const detail = input.sandboxUnavailableDetail ?? "the configured bubblewrap boundary did not pass its startup self-test";
+    if (!input.compareWithCurrentRelease) {
+      throw new UpdateFunctionalProbeError("sandbox-unavailable", detail);
+    }
+    const current = await input.compareWithCurrentRelease({
+      kind: "sandbox-unavailable",
+      reason: detail
+    });
+    if (current.kind !== "sandbox-unavailable") {
+      throw new UpdateFunctionalProbeError("sandbox-unavailable", `${detail}; ${describeCurrentReleaseOutcome(current)}`);
+    }
+    console.warn("[body] update probe: the sandbox is unavailable to this release and the current release alike; preserving fail-closed sandboxing and accepting the bundle as inconclusive");
+    return {
+      harness,
+      sandboxed: false,
+      sessionStarted: false,
+      turnCompleted: false,
+      nativeTools: [],
+      modelAnswer: "unavailable",
+      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 mkdir18(cwd, { recursive: true, mode: 448 });
+  await mkdir19(cwd, { recursive: true, mode: 448 });
   let client;
   try {
     const agentEnv = {
@@ -25459,7 +25472,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) => mkdir18(dir, { recursive: true })));
+      await Promise.all(homeStateDirs.map((dir) => mkdir19(dir, { recursive: true })));
       spawnCommand = wrapAgentCommand({
         bwrapPath: input.config.bwrapPath,
         spec: {
@@ -25609,7 +25622,7 @@ async function runUpdateFunctionalProbe(input) {
 
 // apps/body/dist/current-release-probe.js
 import { spawn as spawn7 } from "node:child_process";
-import { dirname as dirname14, join as join8 } from "node:path";
+import { dirname as dirname15, join as join9 } from "node:path";
 init_self_update();
 var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 12e4;
 var UPDATE_PROBE_COMMAND = "update-probe";
@@ -25631,6 +25644,9 @@ function parseReport(line) {
   if (report.probe === "failed" && typeof report.reason === "string") {
     return { probe: "failed", reason: report.reason };
   }
+  if (report.probe === "sandbox-unavailable" && typeof report.reason === "string") {
+    return { probe: "sandbox-unavailable", reason: report.reason };
+  }
   return void 0;
 }
 function outcomeFromReport(report) {
@@ -25639,12 +25655,17 @@ function outcomeFromReport(report) {
       return { kind: "served" };
     case "refused":
       return { kind: "refused", status: report.status, reason: report.reason };
+    case "sandbox-unavailable":
+      return { kind: "sandbox-unavailable", reason: report.reason };
     case "failed":
+      if (report.reason.startsWith("functional update probe failed (sandbox-unavailable):")) {
+        return { kind: "sandbox-unavailable", reason: report.reason };
+      }
       return { kind: "unavailable", reason: report.reason };
   }
 }
 async function probeReleaseInSubprocess(input) {
-  const bundleDir = join8(input.layout.releasesRoot, input.releaseId);
+  const bundleDir = join9(input.layout.releasesRoot, input.releaseId);
   const entrypoint = await resolveBundleEntrypoint(bundleDir);
   if (!entrypoint) {
     return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
@@ -25707,7 +25728,7 @@ async function runUpdateProbeCommand(args, options = {}) {
   const runtime = await readRuntimeRecord(configPath);
   const agent = runtimeAgentCommand(runtime);
   const config = loadBodyConfig({
-    workspaceRoot: join8(dirname14(configPath), "workspace"),
+    workspaceRoot: join9(dirname15(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env: { ...env, BUZZ_AGENT_BIN: agent.command, BUZZ_DEV_MCP_BIN: runtime.mcpBinary },
     agent
@@ -25725,21 +25746,22 @@ async function runUpdateProbeCommand(args, options = {}) {
   }
   const layout = beelineInstallLayout(env);
   const releaseId = (layout && await activeReleaseId(layout).catch(() => void 0)) ?? "unknown";
-  const runtimeDir = dirname14(configPath);
+  const runtimeDir = dirname15(configPath);
   const outcome = await probeOutcome(() => (options.probe ?? runUpdateFunctionalProbe)({
     config,
     runtimeDir,
     releaseId,
     sandboxRequired: runtime.sandbox !== "off",
+    sandboxUnavailableDetail: sandbox.advisory,
     // The successor's probe still holds `<runtimeDir>/update-functional-probe`.
-    probeRoot: join8(runtimeDir, "current-release-probe")
+    probeRoot: join9(runtimeDir, "current-release-probe")
   }));
-  const report = outcome.kind === "served" ? { probe: "served" } : outcome.kind === "refused" ? { probe: "refused", status: outcome.status, reason: outcome.reason } : { probe: "failed", reason: outcome.reason };
+  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 writeFile14 } from "node:fs/promises";
+import { readFile as readFile13, readdir as readdir5, rename as rename6, writeFile as writeFile15 } from "node:fs/promises";
 import { resolve as resolve27 } from "node:path";
 var DAEMON_RELEASE_STATUS_FILE = "release-status.json";
 var RELEASE_VERSION = /^v\d+\.\d+\.\d+$/;
@@ -25759,7 +25781,7 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
   };
   const target = resolve27(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
   const temporary = `${target}.${status.pid}.tmp`;
-  await writeFile14(temporary, `${JSON.stringify(status, null, 2)}
+  await writeFile15(temporary, `${JSON.stringify(status, null, 2)}
 `, { mode: 384 });
   await rename6(temporary, target);
   return status;
@@ -25893,7 +25915,7 @@ var DaemonExitError = class extends Error {
 };
 async function runStoredDaemon(pathOrPointer) {
   const configPath = await resolveRuntimeConfigPath(pathOrPointer);
-  daemonFailureRuntimeDir = dirname15(configPath);
+  daemonFailureRuntimeDir = dirname16(configPath);
   const accessMigration = await migrateRuntimeRecordAccessPolicy(configPath);
   let runtime = accessMigration.runtime;
   if (!runtime.transport) {
@@ -25905,7 +25927,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile15(resolve29(dirname15(configPath), "daemon.pid"), `${process.pid}
+  await writeFile16(resolve29(dirname16(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -25913,7 +25935,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve29(dirname15(configPath), "workspace"),
+    workspaceRoot: resolve29(dirname16(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -25948,7 +25970,7 @@ async function runStoredDaemon(pathOrPointer) {
   const stop = () => controller.abort();
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
-  const runtimeDir = dirname15(configPath);
+  const runtimeDir = dirname16(configPath);
   const layout = beelineInstallLayout(process.env);
   const notifier = new SystemdNotifier();
   let rollbackAlertDrain;
@@ -26030,6 +26052,7 @@ async function runStoredDaemon(pathOrPointer) {
               runtimeDir,
               releaseId: loadedRelease ?? "unknown",
               sandboxRequired: runtime.sandbox !== "off",
+              sandboxUnavailableDetail: sandbox.advisory,
               ...currentReleaseId ? {
                 compareWithCurrentRelease: async (appeal) => {
                   console.warn(`[thin-core] successor probe got no answer from the provider (${appeal.reason}); probing the current release ${currentReleaseId} for the same outcome`);
@@ -26094,7 +26117,7 @@ async function runStoredDaemon(pathOrPointer) {
   } finally {
     clearInterval(scratchSweepTimer);
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve29(dirname15(configPath), "daemon.pid");
+    const pidPath = resolve29(dirname16(configPath), "daemon.pid");
     const recorded = Number((await readFile14(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
       await unlink5(pidPath).catch(() => void 0);
@@ -26154,10 +26177,7 @@ async function main() {
     await repairInstallForwarders(startupLayout).catch(() => void 0);
   }
   const interactiveUi = command !== "daemon" && Boolean(stdin4.isTTY && stdout5.isTTY);
-  const llmEnvFile = process.env.BUZZY_BODY_LLM_FILE;
-  const workspaceRoot = process.env.BUZZY_BODY_WORKSPACE ?? "./body-workspace";
   if (command === "--version" || command === "version") {
-    const config = loadBodyConfig({ workspaceRoot, llmEnvFile });
     console.log(import_picocolors3.default.bold("beeline 0.0.0"));
     const layout = beelineInstallLayout(process.env);
     if (layout) {
@@ -26165,9 +26185,6 @@ async function main() {
       const active = await activeReleaseId(layout);
       console.log(`${import_picocolors3.default.dim("installed bundle:")} ${describeIdentity(identity)}${active ? ` (release ${active})` : ""}`);
     }
-    console.log(`${import_picocolors3.default.dim("[body] agent binary:")} ${config.agentCommand ?? config.agentBinary}`);
-    console.log(`${import_picocolors3.default.dim("[body] mcp binary:")} ${config.mcpBinary}`);
-    console.log(`${import_picocolors3.default.dim("[body] read-only mcp:")} ${config.readonlyMcpCommand}`);
     return;
   }
   if (command === "daemon") {
@@ -26177,7 +26194,7 @@ 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) => dirname15(candidate).endsWith(agentPubkey));
+      configPath = configs.find((candidate) => dirname16(candidate).endsWith(agentPubkey));
     }
     if (!configPath && agentPubkey) {
       throw new DaemonExitError(`unknown agent ${agentPubkey}: no durable runtime exists; refusing systemd restart loop`, UNKNOWN_AGENT_EXIT_STATUS);
@@ -26205,7 +26222,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) => dirname15(candidate).endsWith(agentPubkey));
+    const configPath = configs.find((candidate) => dirname16(candidate).endsWith(agentPubkey));
     if (!configPath)
       throw new Error(`no stored runtime found for agent ${agentPubkey}`);
     const runtime = await readRuntimeRecord(configPath);