usebeeline 0.0.65 → 0.0.71

package/dist/usebeeline.mjs

@@ -3986,10 +3986,10 @@ __export(self_update_exports, {
 });
 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), {
@@ -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";
@@ -8129,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";
@@ -16910,32 +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 orderInboxItems(items) {
-  return [...items].sort((left, right) => {
-    const leftMatch = left.cursor?.match(/^(\d+),([0-9a-f]{64})$/);
-    const rightMatch = right.cursor?.match(/^(\d+),([0-9a-f]{64})$/);
-    if (!leftMatch || !rightMatch)
-      return 0;
-    const timeOrder = BigInt(leftMatch[1]) - BigInt(rightMatch[1]);
-    if (timeOrder !== 0n)
-      return timeOrder < 0n ? -1 : 1;
-    return leftMatch[2] < rightMatch[2] ? -1 : leftMatch[2] > rightMatch[2] ? 1 : 0;
-  });
-}
 function isAgentRemovedError(error) {
   return error instanceof DaemonApiError && error.status === 403 && error.code === AGENT_REMOVED_CODE;
 }
@@ -16975,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();
@@ -17058,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);
@@ -17153,8 +17166,8 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 import { execFile as execFile5 } from "node:child_process";
 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
@@ -17207,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"
@@ -17798,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.`);
@@ -17861,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",
@@ -17915,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) {
@@ -17994,128 +18001,168 @@ 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;
+  let pushIntakeAcknowledged = false;
+  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, capabilities) => {
+    const acknowledged = connected && capabilities?.pushIntake === true;
+    if (pushIntakeAcknowledged !== acknowledged) {
+      pushIntakeAcknowledged = acknowledged;
+      wake?.(!connected);
+    } else 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), pushIntakeAcknowledged ? 6e4 : 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 { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir10 } from "node:fs/promises";
+import { mkdir as mkdir11 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
-// packages/api-contract/dist/daemon-operations.js
-var AGENT_TO_AGENT_HOP_CAP = 3;
-
-// 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"
-];
-function isServerEventKind(value) {
-  return SERVER_EVENT_KINDS.includes(value);
-}
-var RESUME_KINDS = ["grant-decided"];
-function isResumeKind(value) {
-  return RESUME_KINDS.includes(value);
-}
-var CONTROL_KINDS = ["turn-cancelled"];
-function isControlKind(value) {
-  return CONTROL_KINDS.includes(value);
-}
-
-// apps/body/dist/agent-response-rule.js
-var INBOX_DEDUPLICATION_LIMIT = 1e4;
-var CONTINUITY_WINDOW_LIMIT = 200;
-var AgentResponseRule = class {
-  agentIds = /* @__PURE__ */ new Set();
-  lastAgentBySender = /* @__PURE__ */ new Map();
-  observedIds = /* @__PURE__ */ new Set();
-  recentMessages = [];
-  localReplySequence = 0;
-  setAgents(agentIds) {
-    this.agentIds = new Set(agentIds);
-    this.rebuildLastAgentBySender();
-  }
-  observeAll(items) {
-    for (const item of items)
-      this.observe(item);
-  }
-  replaceHistory(items) {
-    this.recentMessages.length = 0;
-    this.lastAgentBySender.clear();
-    for (const item of items)
-      this.record(item);
-  }
-  observe(item) {
-    if (this.observedIds.has(item.id))
-      return;
-    this.observedIds.add(item.id);
-    while (this.observedIds.size > INBOX_DEDUPLICATION_LIMIT)
-      this.observedIds.delete(this.observedIds.values().next().value);
-    this.record(item);
-  }
-  record(item) {
-    if (item.type !== "message")
-      return;
-    this.recentMessages.push(item);
-    while (this.recentMessages.length > CONTINUITY_WINDOW_LIMIT)
-      this.recentMessages.shift();
-    this.rebuildLastAgentBySender();
-  }
-  rebuildLastAgentBySender() {
-    this.lastAgentBySender.clear();
-    for (const recent of this.recentMessages) {
-      if (!recent.agentAuthor && !this.agentIds.has(recent.authorId))
-        continue;
-      const addressed = new Set(recent.mentionIds);
-      if (recent.requestAuthorId)
-        addressed.add(recent.requestAuthorId);
-      if (recent.replyToAuthorId)
-        addressed.add(recent.replyToAuthorId);
-      for (const senderId of addressed) {
-        if (senderId !== recent.authorId)
-          this.lastAgentBySender.set(senderId, recent.authorId);
-      }
-    }
-  }
-  noteReply(agentId, senderIds) {
-    this.record({
-      id: `local-reply-${agentId}-${this.localReplySequence++}`,
-      authorId: agentId,
-      type: "message",
-      mentionIds: [...senderIds],
-      agentAuthor: true
-    });
-  }
-  /** Whether trigger 2 applies. Explicit mention handling stays with each intake loop. */
-  continues(item, agentId) {
-    if (item.type !== "message" || item.authorId === agentId)
-      return false;
-    if (!this.agentIds.has(agentId))
-      return false;
-    if ((item.agentAuthor || this.agentIds.has(item.authorId)) && (item.agentHopCount ?? 0) >= AGENT_TO_AGENT_HOP_CAP)
-      return false;
-    if (item.agentMentionIds?.length || item.mentionIds.some((mentioned) => this.agentIds.has(mentioned)))
-      return false;
-    if (item.replyToMessageId)
-      return item.replyToAuthorId === agentId;
-    if (this.lastAgentBySender.get(item.authorId) !== agentId)
-      return false;
-    return true;
-  }
-};
-
 // 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";
@@ -18218,7 +18265,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";
@@ -18348,8 +18395,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
   });
@@ -18383,8 +18430,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
   });
@@ -18840,14 +18887,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) {
@@ -18899,7 +18946,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);
@@ -19011,18 +19058,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);
@@ -19052,8 +19099,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);
@@ -19073,7 +19120,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;
@@ -19241,7 +19288,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;
   }
@@ -19253,7 +19300,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);
@@ -19263,14 +19310,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 {
@@ -19313,8 +19360,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`;
@@ -19334,7 +19381,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,
@@ -19358,8 +19405,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 };
@@ -19545,13 +19592,6 @@ function isCornerStatusRestatement(reply, systemLines) {
 var TurnStoppedError = class extends Error {
   name = "TurnStoppedError";
 };
-function turnStopRequestId(item, agentId) {
-  if (item.type !== "system" || !item.mentionIds.includes(agentId))
-    return void 0;
-  if (item.systemEvent?.kind !== "turn-cancelled")
-    return void 0;
-  return item.requestId || void 0;
-}
 
 // apps/body/dist/turn-stream.js
 function durableReplyText(agentText) {
@@ -19724,7 +19764,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) {
@@ -19748,7 +19788,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) {
@@ -20153,6 +20193,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 },
@@ -20358,41 +20399,64 @@ 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.";
 
-// apps/body/dist/monolith-room-turn.js
-import { mkdir as mkdir8 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+// apps/body/dist/warm-transcript.js
+var WARM_TRANSCRIPT_OVERLAP = 8;
+var WarmTranscript = class {
+  sessionId;
+  delivered = /* @__PURE__ */ new Set();
+  /**
+   * The rows this prompt should render. A row counts as delivered once it has
+   * been handed to a session: a prompt that times out was still received by the
+   * harness, and a prompt that could not be handed over at all takes the
+   * session down with it, which resets the memory on the next activation.
+   */
+  select(sessionId, rows) {
+    if (!sessionId || sessionId !== this.sessionId) {
+      this.sessionId = sessionId;
+      this.delivered.clear();
+    }
+    const overlapFrom = Math.max(0, rows.length - WARM_TRANSCRIPT_OVERLAP);
+    const selected = rows.filter((row, index) => index >= overlapFrom || !this.delivered.has(row.id));
+    for (const row of rows)
+      this.delivered.add(row.id);
+    return { rows: selected, elided: rows.length - selected.length };
+  }
+  /** Render a selection, and say plainly when it is only what is new. */
+  static render(selection, whole, sinceLastTurn) {
+    const transcript = selection.rows.map((row) => row.line).join("\n");
+    if (!transcript)
+      return "";
+    return `${selection.elided ? sinceLastTurn : whole}
+${transcript}`;
+  }
+};
 
-// packages/api-contract/dist/scheduled-prompts.js
-var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
-var SCHEDULE_RAN_VERB = "ran a schedule for";
+// apps/body/dist/turn-receipt-heartbeat.js
+var TURN_RECEIPT_HEARTBEAT_MS = 3e4;
+async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
+  let tail = Promise.resolve();
+  const timer = setInterval(() => {
+    tail = tail.catch(() => void 0).then(() => api.execute("postAgentTurnReceipt", {
+      ...receipt,
+      status: "working",
+      heartbeat: true
+    })).then(() => void 0).catch(onHeartbeatError);
+  }, TURN_RECEIPT_HEARTBEAT_MS);
+  timer.unref?.();
+  try {
+    return await task();
+  } finally {
+    clearInterval(timer);
+    await tail;
+  }
+}
 
 // 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 = [
@@ -20646,7 +20710,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);
@@ -20668,58 +20732,65 @@ var TurnTraceFile = class {
   }
 };
 
-// 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", {
-      ...receipt,
-      status: "working",
-      heartbeat: true
-    })).then(() => void 0).catch(onHeartbeatError);
-  }, TURN_RECEIPT_HEARTBEAT_MS);
-  timer.unref?.();
-  try {
-    return await task();
-  } finally {
-    clearInterval(timer);
-    await tail;
+// apps/body/dist/corner-github-auth.js
+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 mkdir9(bin, { recursive: true, mode: 448 });
+  const common = {
+    node: process.execPath,
+    cli: input.cliEntrypoint,
+    config: input.runtimeConfigPath,
+    room: input.roomId
+  };
+  await writeLauncher(resolve18(bin, "git"), { ...common, command: input.gitBinary });
+  if (input.ghBinary)
+    await writeLauncher(resolve18(bin, "gh"), { ...common, command: input.ghBinary });
+  return {
+    PATH: [bin, input.inheritedPath].filter(Boolean).join(delimiter2),
+    // Static startup tokens take precedence over the refreshed token in gh.
+    GH_TOKEN: "",
+    GITHUB_TOKEN: ""
+  };
+}
+async function writeLauncher(path, config) {
+  const source = `#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+const config = ${JSON.stringify(config)};
+const authFailure = /(?:authentication failed|bad credentials|could not read username|http(?:\\/\\d(?:\\.\\d)?)? 40[13]|status (?:code )?40[13])/i;
+function token() {
+  const result = spawnSync(config.node, [config.cli, 'corner-read-token', '--config', config.config, '--room', config.room], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    process.stderr.write(result.stderr || 'Beeline could not refresh the repository credential.\\n');
+    process.exit(result.status || 1);
   }
+  return result.stdout.trim();
+}
+function run(value) {
+  const env = { ...process.env, GH_TOKEN: value, GITHUB_TOKEN: value, GIT_TERMINAL_PROMPT: '0' };
+  return spawnSync(config.command, process.argv.slice(2), { env, encoding: 'buffer', stdio: ['inherit', 'pipe', 'pipe'] });
+}
+let result = run(token());
+const diagnostic = Buffer.concat([result.stdout || Buffer.alloc(0), result.stderr || Buffer.alloc(0)]).toString('utf8');
+if (result.status !== 0 && authFailure.test(diagnostic)) result = run(token());
+if (result.stdout) process.stdout.write(result.stdout);
+if (result.stderr) process.stderr.write(result.stderr);
+if (result.error) throw result.error;
+process.exit(result.status ?? 1);
+`;
+  await writeFile8(path, source, { mode: 448 });
+  await chmod3(path, 448);
 }
 
-// apps/body/dist/warm-transcript.js
-var WARM_TRANSCRIPT_OVERLAP = 8;
-var WarmTranscript = class {
-  sessionId;
-  delivered = /* @__PURE__ */ new Set();
-  /**
-   * The rows this prompt should render. A row counts as delivered once it has
-   * been handed to a session: a prompt that times out was still received by the
-   * harness, and a prompt that could not be handed over at all takes the
-   * session down with it, which resets the memory on the next activation.
-   */
-  select(sessionId, rows) {
-    if (!sessionId || sessionId !== this.sessionId) {
-      this.sessionId = sessionId;
-      this.delivered.clear();
-    }
-    const overlapFrom = Math.max(0, rows.length - WARM_TRANSCRIPT_OVERLAP);
-    const selected = rows.filter((row, index) => index >= overlapFrom || !this.delivered.has(row.id));
-    for (const row of rows)
-      this.delivered.add(row.id);
-    return { rows: selected, elided: rows.length - selected.length };
-  }
-  /** Render a selection, and say plainly when it is only what is new. */
-  static render(selection, whole, sinceLastTurn) {
-    const transcript = selection.rows.map((row) => row.line).join("\n");
-    if (!transcript)
-      return "";
-    return `${selection.elided ? sinceLastTurn : whole}
-${transcript}`;
-  }
-};
+// 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) {
@@ -20727,15 +20798,6 @@ function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_S
     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;
-}
 function isScheduledPrompt(item, agentId) {
   if (item.type !== "system" || !item.mentionIds.includes(agentId))
     return false;
@@ -20754,30 +20816,6 @@ function inboxItemAuthorName(item, agentId, names) {
 function inboxItemPromptBody(item, agentId) {
   return isScheduledPrompt(item, agentId) ? item.systemEvent?.consequence ?? item.body : item.body;
 }
-function isSubscribedEvent(item, agentId) {
-  const kind = item.systemEvent?.kind;
-  return item.type === "system" && kind !== void 0 && !isResumeKind(kind) && !isControlKind(kind) && item.mentionIds.includes(agentId);
-}
-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 isGrantDecisionLine(item, agentId) {
-  return item.type === "system" && item.mentionIds.includes(agentId) && parseGrantDecisionLine(item.body) !== void 0;
-}
-function inboxItemTriggersTurn(item, agentId, continuesExchange = false) {
-  if (item.authorId === agentId)
-    return false;
-  if (item.type === "message" && continuesExchange)
-    return true;
-  if (!item.mentionIds.includes(agentId))
-    return false;
-  return item.type === "message" || isSubscribedEvent(item, agentId) || isScheduledPrompt(item, agentId) || isGrantDecisionLine(item, agentId);
-}
 function pendingGrantToolCall(call) {
   if (!/(?:^|[._:/-])request_grant$/i.test(call.title ?? ""))
     return false;
@@ -20800,6 +20838,7 @@ function roomMentionDirectory(roster, selfId) {
     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");
@@ -20812,7 +20851,8 @@ function agentReplyMentionIds(text2, roster, authorId) {
   for (const member of roster.members) {
     if (member.identityId === authorId)
       continue;
-    for (const raw of [member.name, member.handle, member.soul?.name]) {
+    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;
@@ -20823,7 +20863,7 @@ function agentReplyMentionIds(text2, roster, authorId) {
     }
   }
   for (const member of roster.members) {
-    if (member.identityId === authorId || !member.handle)
+    if (member.identityId === authorId || member.kind === "agent" || !member.handle)
       continue;
     const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
     const canonical = aliases.get(handle);
@@ -20846,12 +20886,11 @@ function agentReplyMentionIds(text2, roster, authorId) {
 }
 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;
   }
@@ -20869,7 +20908,6 @@ var MonolithRoomTurnLoop = class {
   turnInstructionPrefix = "";
   activeTurn;
   queuedTurns = [];
-  continuityRebuildRequested = false;
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
   /** Whether the pinned model takes images; `undefined` when the pin did not say. */
@@ -20888,18 +20926,21 @@ var MonolithRoomTurnLoop = class {
   pausedOnGrantRequestId;
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
-  /** Per-sender continuity, shared in shape with corner intake. */
-  responseRule = new AgentResponseRule();
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
+    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.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()
+      turn: () => {
+        const turn = this.currentTurnForRunner();
+        return turn ? { ...turn, generationId: this.commandContext.generationId } : void 0;
+      }
     });
   }
   isBusy() {
@@ -20952,9 +20993,6 @@ var MonolithRoomTurnLoop = class {
     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);
   }
@@ -20971,7 +21009,6 @@ var MonolithRoomTurnLoop = class {
       workspaceId: this.options.workspaceId
     });
     this.memberNames = new Map(roster.members.map((member) => [member.identityId, member.name]));
-    this.responseRule.setAgents(roster.members.filter((member) => member.kind === "agent").map((member) => member.identityId));
     return roster;
   }
   /**
@@ -20993,7 +21030,7 @@ var MonolithRoomTurnLoop = class {
     const cached = this.deliveredAttachments.get(item.id);
     if (cached)
       return cached;
-    const delivered = await deliverAttachments(item.attachments, join5(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
+    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;
   }
@@ -21060,7 +21097,7 @@ var MonolithRoomTurnLoop = class {
       agentName: self?.name ?? this.agent.name
     });
     const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
-    await mkdir8(this.options.cwd, { recursive: true });
+    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,
@@ -21086,14 +21123,14 @@ var MonolithRoomTurnLoop = 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) => mkdir8(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir10(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
     if (attachScratchRoot)
-      await mkdir8(attachScratchRoot, { recursive: true });
+      await mkdir10(attachScratchRoot, { recursive: true });
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
@@ -21119,6 +21156,7 @@ var MonolithRoomTurnLoop = class {
         // 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 } : {}
       })
@@ -21251,8 +21289,6 @@ var MonolithRoomTurnLoop = class {
     }).finally(() => {
       if (this.activeTurn === active) {
         this.activeTurn = void 0;
-        if (active.rebuildContinuity)
-          this.continuityRebuildRequested = true;
         this.wakeIntake?.();
         this.wakeIntake = void 0;
       }
@@ -21279,24 +21315,6 @@ var MonolithRoomTurnLoop = class {
     if (this.client && this.sessionId)
       this.client.sessionCancel(this.sessionId);
   }
-  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);
-      }
-    });
-  }
   async prompt(active) {
     const { item } = active;
     const api = this.options.api;
@@ -21309,7 +21327,7 @@ var MonolithRoomTurnLoop = class {
         agentId: this.agent.publicKey,
         roomId: this.options.roomId,
         requestId: item.id,
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
+        generationId: this.commandContext.generationId
       }, async () => {
         await api.execute("postAgentActivity", {
           agentId: this.agent.publicKey,
@@ -21339,7 +21357,7 @@ var MonolithRoomTurnLoop = class {
             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())
           }));
-          const grantDecision = isGrantDecisionLine(item, this.agent.publicKey);
+          const grantDecision = this.commandContext.current?.action === "resume";
           const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
           if (grantDecision)
             this.pausedOnGrantRequestId = void 0;
@@ -21417,8 +21435,7 @@ var MonolithRoomTurnLoop = class {
             }
           }
           if (active.cancelled) {
-            const stoppedText = durableReplyText(result.agentText);
-            await stream.settle(stoppedText, stoppedText ? { triggerMessageId: item.id } : {});
+            stream.close();
             throw new TurnStoppedError("turn stopped by the requester");
           }
           active.phase = "finishing";
@@ -21453,21 +21470,10 @@ var MonolithRoomTurnLoop = class {
             reply = stripCornerOpenEcho(reply);
           }
           const mentionIds = reply ? agentReplyMentionIds(reply, roster, this.agent.publicKey) : [];
-          const continuitySenders = reply ? [item.authorId, ...mentionIds] : [];
-          if (continuitySenders.length) {
-            active.continuitySenders = new Set(continuitySenders);
-            active.rebuildContinuity = true;
-          }
           await trace.measure("publish", () => stream.settle(reply, reply ? {
             triggerMessageId: item.id,
             mentionIds
-          } : {}, reply ? (posted) => {
-            this.responseRule.noteReply(this.agent.publicKey, [
-              item.authorId,
-              ...posted.mentionIds ?? []
-            ]);
-            active.rebuildContinuity = false;
-          } : void 0));
+          } : {}));
         }, { priority: "interactive", roomKey: this.options.roomId });
       }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
@@ -21475,7 +21481,7 @@ var MonolithRoomTurnLoop = class {
         roomId: this.options.roomId,
         requestId: item.id,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
+        generationId: this.commandContext.generationId
       });
       await trace.finish("complete");
     } catch (error) {
@@ -21490,7 +21496,7 @@ var MonolithRoomTurnLoop = class {
         roomId: this.options.roomId,
         requestId: item.id,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`,
+        generationId: this.commandContext.generationId,
         reason
       });
       await trace.finish("failed", reason);
@@ -21501,137 +21507,37 @@ var MonolithRoomTurnLoop = class {
   }
   async run() {
     const { api, roomId, signal } = this.options;
-    let cursor3;
-    const processedInboxIds = /* @__PURE__ */ new Set();
-    const deferredContinuity = /* @__PURE__ */ new Map();
-    const pushedInbox = [];
-    let pendingPushedCursor;
-    let liveConnected = false;
-    let stopLive;
     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);
-      const [history] = await Promise.all([
-        api.execute("getRoomConversation", { roomId, limit: 200, window: "continuity" }),
-        this.roster()
-      ]);
-      this.responseRule.observeAll(history.items);
-      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
-      });
-      while (!signal?.aborted) {
-        try {
-          if (!this.activeTurn && this.continuityRebuildRequested) {
-            const history2 = await api.execute("getRoomConversation", {
-              roomId,
-              limit: 200,
-              window: "continuity"
-            });
-            this.responseRule.replaceHistory(history2.items);
-            this.continuityRebuildRequested = false;
-          }
-          if (!this.activeTurn && deferredContinuity.size === 0 && 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 deferred = this.activeTurn ? [] : [...deferredContinuity.values()];
-          if (!this.activeTurn)
-            deferredContinuity.clear();
-          const delivered = orderInboxItems([
-            ...deferred,
-            ...pushedInbox.splice(0),
-            ...inbox.items
-          ]);
-          for (const item of delivered) {
-            if (processedInboxIds.has(item.id) || deferredContinuity.has(item.id))
-              continue;
-            const triggers = inboxItemTriggersTurn(item, this.agent.publicKey, this.responseRule.continues(item, this.agent.publicKey));
-            const finishing = this.activeTurn;
-            if (!triggers && finishing?.phase === "finishing" && finishing.continuitySenders?.has(item.authorId) && item.type === "message" && !item.replyToMessageId) {
-              deferredContinuity.set(item.id, item);
-              continue;
-            }
-            processedInboxIds.add(item.id);
-            while (processedInboxIds.size > INBOX_DEDUPLICATION_LIMIT)
-              processedInboxIds.delete(processedInboxIds.values().next().value);
-            const stopped = turnStopRequestId(item, this.agent.publicKey);
-            if (stopped) {
-              this.stopTurn(stopped);
-              continue;
-            }
-            this.responseRule.observe(item);
-            if (!triggers)
-              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([
-              wait(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 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(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);
     }
   }
@@ -21641,70 +21547,6 @@ function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsI
   const rendered = author ? `${author}: ${message}` : message;
   return [rendered, ...attachmentPromptLines(attachments, delivered, harnessAcceptsImages)].join("\n");
 }
-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 });
-  });
-}
-
-// apps/body/dist/corner-github-auth.js
-import { chmod as chmod3, mkdir as mkdir9, writeFile as writeFile7 } 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 mkdir9(bin, { recursive: true, mode: 448 });
-  const common = {
-    node: process.execPath,
-    cli: input.cliEntrypoint,
-    config: input.runtimeConfigPath,
-    room: input.roomId
-  };
-  await writeLauncher(resolve18(bin, "git"), { ...common, command: input.gitBinary });
-  if (input.ghBinary)
-    await writeLauncher(resolve18(bin, "gh"), { ...common, command: input.ghBinary });
-  return {
-    PATH: [bin, input.inheritedPath].filter(Boolean).join(delimiter2),
-    // Static startup tokens take precedence over the refreshed token in gh.
-    GH_TOKEN: "",
-    GITHUB_TOKEN: ""
-  };
-}
-async function writeLauncher(path, config) {
-  const source = `#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-const config = ${JSON.stringify(config)};
-const authFailure = /(?:authentication failed|bad credentials|could not read username|http(?:\\/\\d(?:\\.\\d)?)? 40[13]|status (?:code )?40[13])/i;
-function token() {
-  const result = spawnSync(config.node, [config.cli, 'corner-read-token', '--config', config.config, '--room', config.room], { encoding: 'utf8' });
-  if (result.status !== 0) {
-    process.stderr.write(result.stderr || 'Beeline could not refresh the repository credential.\\n');
-    process.exit(result.status || 1);
-  }
-  return result.stdout.trim();
-}
-function run(value) {
-  const env = { ...process.env, GH_TOKEN: value, GITHUB_TOKEN: value, GIT_TERMINAL_PROMPT: '0' };
-  return spawnSync(config.command, process.argv.slice(2), { env, encoding: 'buffer', stdio: ['inherit', 'pipe', 'pipe'] });
-}
-let result = run(token());
-const diagnostic = Buffer.concat([result.stdout || Buffer.alloc(0), result.stderr || Buffer.alloc(0)]).toString('utf8');
-if (result.status !== 0 && authFailure.test(diagnostic)) result = run(token());
-if (result.stdout) process.stdout.write(result.stdout);
-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 chmod3(path, 448);
-}
 
 // apps/body/dist/monolith-corner-turn.js
 var execFileAsync3 = promisify3(execFile4);
@@ -21835,18 +21677,13 @@ async function cornerToolActivity(call, worktreePath, 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);
-}
 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;
   }
@@ -21878,15 +21715,9 @@ var MonolithCornerTurnLoop = class {
   turnTraceSink;
   memberNames = /* @__PURE__ */ new Map();
   /** Agent identities in this Workspace, so a mention can be told from a human's. */
-  agentMembers = /* @__PURE__ */ new Set();
-  rosterAvailable = false;
   /** Per-sender continuity, shared in shape with top-level Room intake. */
-  responseRule = new AgentResponseRule();
-  continuityRebuildRequested = false;
   /** The member agent that owns corner-wide lifecycle facts such as checks. */
-  carrier;
   /** The last server check state that started a turn; the same state never starts another. */
-  lastChecksState;
   /**
    * 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
@@ -21897,6 +21728,8 @@ var MonolithCornerTurnLoop = class {
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
+    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.worktreePath,
@@ -21907,15 +21740,12 @@ var MonolithCornerTurnLoop = class {
         surface: "corner",
         ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {}
       }),
-      turn: () => this.currentTurn
+      turn: () => this.currentTurn ? { ...this.currentTurn, generationId: this.commandContext.generationId } : void 0
     });
   }
   isBusy() {
     return this.busy;
   }
-  currentPrincipalCanDrive(_workspaceId, _principalId) {
-    return Promise.resolve(true);
-  }
   refreshPersonaForSoulUpdate() {
     return this.options.scheduler.suspend(this.options.cornerId);
   }
@@ -21950,15 +21780,8 @@ 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));
-    this.responseRule.setAgents(this.agentMembers);
-    this.rosterAvailable = true;
     return roster;
   }
-  async reconcileRoster() {
-    if (!this.rosterAvailable)
-      await this.roster().catch(() => void 0);
-  }
   /**
    * 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.
@@ -22011,7 +21834,7 @@ var MonolithCornerTurnLoop = class {
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name
     });
-    await mkdir10(this.options.worktreePath, { 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,
@@ -22056,13 +21879,13 @@ var MonolithCornerTurnLoop = 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;
     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: {
@@ -22115,6 +21938,7 @@ var MonolithCornerTurnLoop = class {
         // The whole per-session overlay, not an enumerated subset: see
         // `monolith-room-turn.ts`'s matching comment.
         attachScratchRoot,
+        turnContextPath: this.commandContext.path,
         ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
       })
     ];
@@ -22247,14 +22071,13 @@ var MonolithCornerTurnLoop = class {
       ...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);
     try {
       await withTurnReceiptHeartbeat(api, {
         agentId: this.agent.publicKey,
         roomId: cornerId,
         requestId,
-        generationId: `${this.agent.publicKey}:${cornerId}`
+        generationId: this.commandContext.generationId
       }, () => {
         trace.noteScheduler("queue", this.options.scheduler.snapshot());
         trace.start("queue-wait");
@@ -22268,7 +22091,7 @@ var MonolithCornerTurnLoop = class {
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
             api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join6(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            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 requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
@@ -22283,6 +22106,7 @@ var MonolithCornerTurnLoop = class {
             `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),
             [
               `Newest trigger:
 ${trigger}`,
@@ -22414,9 +22238,7 @@ ${trigger}`,
             }
           }
           if (this.stoppedTurns.has(requestId)) {
-            const stoppedText = spoken(durableReplyText(result.agentText));
-            await flushToolCalls(result.toolCalls, stoppedText);
-            await stream.settle(stoppedText);
+            stream.close();
             throw new TurnStoppedError("turn stopped by the requester");
           }
           let reply = durableReplyText(result.agentText);
@@ -22436,12 +22258,11 @@ ${trigger}`,
             console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
           }
           const durableReply = spoken(reply);
-          if (durableReply && requestedById)
-            this.continuityRebuildRequested = true;
-          await trace.measure("publish", () => stream.settle(durableReply, requestedById ? { triggerMessageId: requestId } : {}, durableReply && requestedById ? () => {
-            this.responseRule.noteReply(this.agent.publicKey, [requestedById]);
-            this.continuityRebuildRequested = false;
-          } : void 0));
+          const mentionIds = durableReply ? agentReplyMentionIds(durableReply, roster, this.agent.publicKey) : [];
+          await trace.measure("publish", () => stream.settle(durableReply, durableReply ? {
+            ...requestedById ? { triggerMessageId: requestId } : {},
+            mentionIds
+          } : {}));
         }, { priority: "interactive", roomKey: cornerId });
       }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
@@ -22449,7 +22270,7 @@ ${trigger}`,
         roomId: cornerId,
         requestId,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${cornerId}`
+        generationId: this.commandContext.generationId
       });
       await trace.finish("complete");
     } catch (error) {
@@ -22464,7 +22285,7 @@ ${trigger}`,
         roomId: cornerId,
         requestId,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${cornerId}`,
+        generationId: this.commandContext.generationId,
         reason
       });
       await trace.finish("failed", reason);
@@ -22474,46 +22295,6 @@ ${trigger}`,
       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;
-  }
-  async noteIncomingCarrier(item) {
-    if (item.agentAuthor && !this.agentMembers.has(item.authorId))
-      await this.roster().catch(() => void 0);
-    this.noteCarrier(item.authorId);
-  }
-  /**
-   * Whether a message in this corner is addressed to THIS agent.
-   *
-   * A corner now runs like a Room — every member agent polls it — so an
-   * A server-resolved mention always routes to its agent. Otherwise the one
-   * agent already exchanging messages with this exact sender continues; the
-   * lifecycle carrier is deliberately not a conversational fallback.
-   */
-  addressesThisAgent(item) {
-    if (item.mentionIds.includes(this.agent.publicKey))
-      return true;
-    return this.responseRule.continues(item, this.agent.publicKey);
-  }
   /**
    * Bring this worktree onto the corner's branch as GitHub currently has it,
    * before any work is done on top of it.
@@ -22535,197 +22316,42 @@ ${trigger}`,
       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);
-      for (const item of items) {
-        const stopped = turnStopRequestId(item, this.agent.publicKey);
-        if (stopped)
-          this.stopTurn(stopped);
-      }
-      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,
-      window: "continuity"
-    });
-    await this.roster().catch(() => void 0);
-    this.responseRule.observeAll(history.items);
-    for (const item of history.items) {
-      if (item.type === "message")
-        await this.noteIncomingCarrier(item);
-    }
-    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);
-    }
     try {
-      let pollWithoutWait = false;
-      while (!signal?.aborted) {
-        try {
-          if (this.continuityRebuildRequested) {
-            const reconciled = await api.execute("getRoomConversation", {
-              roomId: cornerId,
-              limit: 200,
-              window: "continuity"
-            });
-            this.responseRule.replaceHistory(reconciled.items);
-            this.carrier = void 0;
-            for (const item of reconciled.items) {
-              if (item.type === "message")
-                await this.noteIncomingCarrier(item);
-            }
-            this.continuityRebuildRequested = false;
-          }
-          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 = orderInboxItems([...pushedInbox.splice(0), ...inbox.items]);
-          for (const item of delivered) {
-            if (processedInboxIds.has(item.id))
-              continue;
-            processedInboxIds.add(item.id);
-            while (processedInboxIds.size > INBOX_DEDUPLICATION_LIMIT)
-              processedInboxIds.delete(processedInboxIds.values().next().value);
-            const stoppedTurn = turnStopRequestId(item, this.agent.publicKey);
-            if (stoppedTurn) {
-              this.stopTurn(stoppedTurn);
-              continue;
-            }
-            if (item.type === "message") {
-              if (item.authorId !== this.agent.publicKey)
-                await this.reconcileRoster();
-              await this.noteIncomingCarrier(item);
-              if (item.authorId === this.agent.publicKey)
-                continue;
-              const addressed = this.addressesThisAgent(item);
-              this.responseRule.observe(item);
-              if (!addressed)
-                continue;
-              const authority = await api.execute("getRoomAuthority", {
-                roomId: cornerId,
-                principalId: item.authorId
-              });
-              const humanPermitted = authority.principalKind === "human" ? await this.currentPrincipalCanDrive(this.options.workspaceId, item.authorId) : false;
-              if (!roomPrincipalMayAddressAgent(authority, humanPermitted))
-                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([
-            wait2(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 wait2(1e3, signal);
-        }
-      }
+      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)
+      });
     } finally {
-      stopLive?.();
-      this.wakeIntake = void 0;
       this.options.grantRunner?.unregister(cornerId);
       await this.options.scheduler.suspend(cornerId);
     }
   }
 };
-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;
@@ -23145,8 +22771,8 @@ async function materializeCornerWorktree(input) {
   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], {
@@ -23333,9 +22959,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()));
@@ -23420,7 +23043,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;
@@ -23443,9 +23066,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 } : {}
     };
   }
@@ -23513,7 +23136,7 @@ var RoomRuntimeCoordinator = class {
     const targetBranch = repository.targetBranch || "main";
     const checkoutId = createHash5("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
     const path = resolve19(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
-    await 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"))) {
@@ -23579,7 +23202,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", {
@@ -23878,9 +23501,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);
@@ -23951,8 +23574,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"]);
@@ -24032,7 +23655,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;
@@ -24107,7 +23730,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."));
@@ -24124,8 +23747,8 @@ async function runStartCommand(args, interactiveUi) {
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { chmod as chmod5, mkdir as 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 { 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
@@ -24769,8 +24392,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);
 }
@@ -24779,9 +24402,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;
@@ -24937,7 +24560,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
       });
@@ -24959,12 +24582,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) {
@@ -24973,8 +24596,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);
 }
@@ -25039,11 +24662,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;
@@ -25453,7 +25076,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
@@ -25681,8 +25304,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) {
@@ -25702,8 +25325,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);
 }
@@ -25725,7 +25348,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;
@@ -25771,6 +25394,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 };
     }
@@ -25783,6 +25409,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})`;
   }
@@ -25794,13 +25422,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 = {
@@ -25830,7 +25478,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: {
@@ -25980,7 +25628,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";
@@ -26002,6 +25650,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) {
@@ -26010,12 +25661,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` };
@@ -26078,7 +25734,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
@@ -26096,21 +25752,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+$/;
@@ -26130,7 +25787,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;
@@ -26264,7 +25921,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) {
@@ -26276,7 +25933,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,
@@ -26284,7 +25941,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
@@ -26319,7 +25976,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;
@@ -26401,6 +26058,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`);
@@ -26465,7 +26123,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);
@@ -26542,7 +26200,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);
@@ -26570,7 +26228,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);