usebeeline 0.0.63 → 0.0.65

package/dist/usebeeline.mjs

@@ -2415,7 +2415,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes7, createHash: createHash7 } = __require("crypto");
+    var { randomBytes: randomBytes7, createHash: createHash8 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -3083,7 +3083,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3452,7 +3452,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash7 } = __require("crypto");
+    var { createHash: createHash8 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3759,7 +3759,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3984,7 +3984,7 @@ __export(self_update_exports, {
   writeUpdateAttemptFixture: () => writeUpdateAttemptFixture,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { access, chmod as chmod4, lstat as lstat2, mkdir as mkdir13, open, readFile as readFile9, rename as rename3, rm as rm5, symlink as symlink2, writeFile as writeFile9 } from "node:fs/promises";
 import { spawn as spawn4 } from "node:child_process";
@@ -4197,7 +4197,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (!response.ok || !response.body) {
       throw new Error(`downloading ${published.file} failed: HTTP ${response.status}`);
     }
-    const hash = createHash5("sha256");
+    const hash = createHash6("sha256");
     const chunks = [];
     for await (const chunk of response.body) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -6912,8 +6912,13 @@ function agentMessageRuns(updates, agentLabel) {
   let current = "";
   let lastWasText = false;
   for (const u4 of updates) {
+    const isToolCall = u4.update.sessionUpdate === "tool_call";
     const delta = normalizeStreamDelta(agentMessageChunkText(u4.update), agentLabel);
     if (!delta) {
+      if (isToolCall && current) {
+        runs.push(current);
+        current = "";
+      }
       lastWasText = false;
       continue;
     }
@@ -6934,9 +6939,6 @@ function agentMessageRuns(updates, agentLabel) {
     return true;
   });
 }
-function joinAgentMessageChunks(updates, agentLabel) {
-  return agentMessageRuns(updates, agentLabel).join("\n\n");
-}
 var RETRY_NARRATION_FRAGMENTS = [
   // `Retrying (attempt 2/3, waiting 4s)` — the pi/ox-alpha shape.
   /retrying\s*\((?:attempt|try)\s*\d+\s*\/\s*\d+(?:,\s*(?:waiting|backoff)\s*\d+(?:\.\d+)?s)?\)/gi,
@@ -7065,6 +7067,7 @@ function toolCallEntries(updates) {
       ...typeof update.title === "string" ? { title: update.title } : {},
       ...typeof update.kind === "string" ? { kind: update.kind } : {},
       ...typeof update.status === "string" ? { status: update.status } : {},
+      ...sessionUpdate === "tool_result" ? { resultReceived: true } : {},
       ..."rawInput" in update ? { rawInput: update.rawInput } : {},
       ..."content" in update ? { content: update.content } : {},
       ..."rawOutput" in update ? { rawOutput: update.rawOutput } : {},
@@ -7327,8 +7330,10 @@ var AcpClient = class extends EventEmitter {
       onToolCalls?.(toolCallEntries(updates));
       if (onChunk) {
         const delta = agentMessageChunkText(u4.update);
-        if (delta)
-          onChunk(delta, joinAgentMessageChunks(updates, this.agentLabel));
+        if (delta) {
+          const runs = agentMessageRuns(updates, this.agentLabel);
+          onChunk(delta, runs.join("\n\n"), runs.at(-1), runs);
+        }
       }
     };
     this.on("session/update", onUpdate);
@@ -16919,6 +16924,18 @@ function laterInboxCursor(left, right) {
     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;
 }
@@ -17134,7 +17151,7 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 
 // apps/body/dist/room-runtime.js
 import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
 import { mkdir as mkdir11, rm as rm4 } from "node:fs/promises";
 import { dirname as dirname6, resolve as resolve19 } from "node:path";
@@ -17979,21 +17996,14 @@ var GrantRunnerServer = class {
 
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir9 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join5 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir10 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join6 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
-// apps/body/dist/agent-home.js
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
-import { chmod as chmod2, copyFile, lstat, mkdir as mkdir4, readFile as readFile6, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile5 } from "node:fs/promises";
-import { 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";
-
-// apps/body/dist/beeline-skill.js
-import { readFileSync as readFileSync3 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
+// 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 = [
@@ -18003,7 +18013,8 @@ var SERVER_EVENT_KINDS = [
   "check-passed",
   "check-failed",
   "merged",
-  "grant-decided"
+  "grant-decided",
+  "turn-cancelled"
 ];
 function isServerEventKind(value) {
   return SERVER_EVENT_KINDS.includes(value);
@@ -18012,6 +18023,103 @@ 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 { 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";
+
+// apps/body/dist/beeline-skill.js
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 
 // packages/api-contract/dist/agent-pairing-code.js
 var CURRENT_AGENT_PAIRING_CODE = /^[0-9A-F]{8}-[0-9A-F]{8}$/;
@@ -19433,6 +19541,18 @@ function isCornerStatusRestatement(reply, systemLines) {
   return statusWords(text2).every((word) => !word || admitted.has(word));
 }
 
+// apps/body/dist/turn-stop.js
+var TurnStoppedError = class extends Error {
+  name = "TurnStoppedError";
+};
+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) {
   return sanitizeAgentReply(agentText);
@@ -19491,7 +19611,8 @@ var AgentTurnStream = class {
   /**
    * Everything the delta hook has seen this turn: every assistant run joined,
    * which is a LONGER string than `PromptResult.agentText` whenever the turn
-   * spoke before a tool call. Nothing durable is derived from it.
+   * spoke before a tool call. This final-reply lane derives nothing durable
+   * from it; a corner records its current normalized run independently.
    */
   get streamedText() {
     return this.latest;
@@ -19514,17 +19635,18 @@ var AgentTurnStream = class {
    * An empty reply settles through the turn receipt instead, and the lane is
    * retracted either way.
    */
-  async settle(reply, fields = {}) {
+  async settle(reply, fields = {}, onReplyPosted) {
     this.close();
     const { api, agentId, roomId, requestId } = this.options;
     if (reply) {
-      await api.execute("postRoomMessage", {
+      const posted = await api.execute("postRoomMessage", {
         roomId,
         requestId,
         text: reply,
         presentation: "message",
         ...fields
       });
+      onReplyPosted?.(posted);
     }
     await this.inFlight;
     await api.execute("retractAgentLiveOutput", {
@@ -20260,58 +20382,14 @@ function checksStateFromLifecycle(lifecycle) {
 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/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 mkdir8 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { join as join5 } from "node:path";
 
-// 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;
-  }
-}
+// 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-trace.js
 import { appendFile, mkdir as mkdir7, readdir as readdir4, rm as rm3 } from "node:fs/promises";
@@ -20590,189 +20668,183 @@ var TurnTraceFile = class {
   }
 };
 
-// apps/body/dist/corner-github-auth.js
-import { chmod as chmod3, mkdir as mkdir8, writeFile as writeFile7 } from "node:fs/promises";
-import { delimiter as delimiter2, resolve as resolve18 } from "node:path";
-async function installCornerGitHubWrappers(input) {
-  const bin = resolve18(input.root, "beeline-github-bin");
-  await mkdir8(bin, { recursive: true, mode: 448 });
-  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);
+// 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;
   }
-  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);
-var TOOL_ARGUMENT_MAX_BYTES = 1200;
-var TOOL_OUTPUT_MAX_BYTES = 3200;
-var TOOL_PATH_LIMIT = 12;
-function oneLine(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
-function serialized(value) {
-  if (typeof value === "string")
-    return value;
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return "";
+// 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
+function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
+  if (isSquireMcpPermissionRequest(request))
+    return false;
+  return isMountedMcpToolPermissionRequest(request, mountedServers);
 }
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+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 clampBytes(value, maxBytes) {
-  const clean4 = value.trim();
-  if (Buffer.byteLength(clean4) <= maxBytes)
-    return clean4;
-  const suffix = "\n\u2026[truncated]";
-  const allowed = maxBytes - Buffer.byteLength(suffix);
-  return `${Buffer.from(clean4).subarray(0, Math.max(0, allowed)).toString("utf8")}${suffix}`;
+function isScheduledPrompt(item, agentId) {
+  if (item.type !== "system" || !item.mentionIds.includes(agentId))
+    return false;
+  if (item.systemEvent?.kind)
+    return item.systemEvent.kind === "schedule-ran";
+  return item.systemEvent?.verb === SCHEDULE_RAN_VERB;
 }
-function outputExcerpt(value) {
-  const redacted = redactToolDetail(serialized(value));
-  if (!redacted.trim())
-    return void 0;
-  if (/\b(?:git[- ]credential|credential[- ]helper)\b/i.test(redacted)) {
-    return "Credential-helper output omitted.";
-  }
-  const lines = redacted.split(/\r?\n/).map((line) => line.trimEnd());
-  if (lines.length <= 8)
-    return clampBytes(lines.join("\n"), TOOL_OUTPUT_MAX_BYTES);
-  return clampBytes([...lines.slice(0, 4), "\u2026[output omitted]\u2026", ...lines.slice(-4)].join("\n"), TOOL_OUTPUT_MAX_BYTES);
+function inboxItemAuthorName(item, agentId, names) {
+  if (isScheduledPrompt(item, agentId))
+    return SCHEDULE_SCHEDULER_NAME;
+  const subject = item.systemEvent?.subject;
+  if (item.type === "system" && subject?.name)
+    return subject.name;
+  return names.get(item.authorId) ?? item.authorId.slice(0, 12);
 }
-function filePaths(value, worktreePath) {
-  const paths = /* @__PURE__ */ new Set();
-  const visit = (candidate, key) => {
-    if (paths.size >= TOOL_PATH_LIMIT || candidate === null || candidate === void 0)
-      return;
-    if (typeof candidate === "string") {
-      if (key && /(?:^|_)(?:path|file|filename|target)$/i.test(key)) {
-        const path = candidate.startsWith(`${worktreePath}/`) ? candidate.slice(worktreePath.length + 1) : candidate;
-        if (path && path.length <= 512)
-          paths.add(redactToolDetail(path));
-      }
-      return;
-    }
-    if (Array.isArray(candidate)) {
-      candidate.forEach((entry) => visit(entry));
-      return;
-    }
-    const object = record(candidate);
-    if (object)
-      Object.entries(object).forEach(([entryKey, entry]) => visit(entry, entryKey));
-  };
-  visit(value);
-  return [...paths];
+function inboxItemPromptBody(item, agentId) {
+  return isScheduledPrompt(item, agentId) ? item.systemEvent?.consequence ?? item.body : item.body;
 }
-function resultStatus(call) {
-  const content = record(call.content) ?? (typeof call.content === "string" ? (() => {
-    try {
-      return record(JSON.parse(call.content));
-    } catch {
-      return void 0;
-    }
-  })() : void 0);
-  const exitCode = content?.exitCode ?? content?.exit_code ?? content?.code;
-  if (typeof exitCode === "number" && Number.isFinite(exitCode))
-    return `exit ${exitCode}`;
-  if (content?.ok === true || content?.success === true)
-    return "ok";
-  if (content?.ok === false || content?.success === false)
-    return "error";
-  return /(?:failed|error|denied)/i.test(call.status ?? "") ? "error" : "ok";
+function isSubscribedEvent(item, agentId) {
+  const kind = item.systemEvent?.kind;
+  return item.type === "system" && kind !== void 0 && !isResumeKind(kind) && !isControlKind(kind) && item.mentionIds.includes(agentId);
 }
-function toolArguments(call) {
-  const raw = record(call.rawInput);
-  const command = typeof call.rawInput === "string" ? call.rawInput : typeof raw?.command === "string" ? raw.command : typeof raw?.cmd === "string" ? raw.cmd : void 0;
-  if (command)
-    return { command: clampBytes(redactToolDetail(command), TOOL_ARGUMENT_MAX_BYTES) };
-  const input = serialized(call.rawInput);
-  return input ? { input: clampBytes(redactToolDetail(input), TOOL_ARGUMENT_MAX_BYTES) } : {};
+function 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 toolCallKey(call, index) {
-  return call.id ?? `tool-${index}`;
+function isGrantDecisionLine(item, agentId) {
+  return item.type === "system" && item.mentionIds.includes(agentId) && parseGrantDecisionLine(item.body) !== void 0;
 }
-function toolCallSettled(call) {
-  return /^(?:completed|complete|failed|error|succeeded|success|passed|done)$/i.test(call.status ?? "");
+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 isSuccessfulCommit(call) {
-  if (/failed|error|denied/i.test(call.status ?? ""))
+function pendingGrantToolCall(call) {
+  if (!/(?:^|[._:/-])request_grant$/i.test(call.title ?? ""))
     return false;
-  return /\bgit\s+commit\b|\bcommit(?:ted)?\s+(?:changes|files?)\b/i.test(`${call.title ?? ""} ${serialized(call.rawInput)}`);
+  return /pending, card posted/i.test(typeof call.content === "string" ? call.content : JSON.stringify(call.content ?? ""));
 }
-async function cornerToolActivity(call, worktreePath, requestedBy) {
-  const operation = oneLine(call.kind ?? "") || "tool";
-  let title = oneLine(redactToolDetail(call.title ?? "")) || `${operation} tool`;
-  if (isSuccessfulCommit(call)) {
-    try {
-      const shown = await execFileAsync3("git", ["-C", worktreePath, "show", "--format=%s", "--name-only", "--no-renames", "HEAD"], { maxBuffer: 1024 * 1024 });
-      const lines = shown.stdout.split(/\r?\n/);
-      const subject = oneLine(lines.shift() ?? "commit");
-      const files = new Set(lines.map(oneLine).filter(Boolean));
-      title = `committed ${files.size} files: ${subject}`;
-    } catch {
-    }
+function roomMentionDirectory(roster, selfId) {
+  const rows = [];
+  for (const member of roster.members) {
+    if (member.identityId === selfId)
+      continue;
+    const handle = member.handle?.trim().replace(/^@/, "");
+    const name = member.name?.trim() ?? "";
+    const alias = handle || name;
+    if (!alias)
+      continue;
+    const kind = member.kind === "agent" ? "agent" : "person";
+    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
   }
-  const paths = filePaths([call.rawInput, call.content, call.locations], worktreePath);
-  const argumentsSummary = toolArguments(call);
-  const output = outputExcerpt(call.content);
-  return {
-    kind: "tool",
-    title: title.slice(0, 240),
-    operation: operation.slice(0, 80),
-    status: resultStatus(call),
-    ...argumentsSummary,
-    ...output ? { output } : {},
-    ...requestedBy ? { requestedBy } : {},
-    ...paths.length ? { files: paths.map((path) => ({ path })) } : {}
-  };
+  if (!rows.length)
+    return "";
+  return [
+    "Room members, and the exact spelling that tags each one:",
+    ...rows,
+    "Write a tag exactly as spelled here. An @name spelled any other way is plain text: it reaches nobody, and nobody is told it was meant for them. Never invent a handle, shorten one, or copy an @name out of the conversation \u2014 old messages carry spellings that no longer exist."
+  ].join("\n");
 }
-var CORNER_CLOSE_POLL_BASE_MS = 12e3;
-function cornerClosePollMs(random = Math.random) {
-  return CORNER_CLOSE_POLL_BASE_MS + Math.floor(random() * 3e3);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var MonolithCornerTurnLoop = class {
+function agentReplyMentionIds(text2, roster, authorId) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const member of roster.members) {
+    if (member.identityId === authorId)
+      continue;
+    for (const raw of [member.name, member.handle, member.soul?.name]) {
+      const display = raw?.trim().replace(/^@/, "");
+      if (!display)
+        continue;
+      const key = display.toLocaleLowerCase();
+      const entry = aliases.get(key) ?? { display, ids: /* @__PURE__ */ new Set() };
+      entry.ids.add(member.identityId);
+      aliases.set(key, entry);
+    }
+  }
+  for (const member of roster.members) {
+    if (member.identityId === authorId || !member.handle)
+      continue;
+    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
+    const canonical = aliases.get(handle);
+    const legacy = `a_${handle}`;
+    if (canonical && !aliases.has(legacy))
+      aliases.set(legacy, { ...canonical, display: legacy });
+  }
+  const mentioned = [];
+  for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
+    if (ids.size !== 1)
+      continue;
+    const pattern = new RegExp(`(^|[\\s([{])@${escapeRegExp(display)}(?=$|[\\s.,!?;:)\\]}])`, "iu");
+    if (!pattern.test(text2))
+      continue;
+    const identityId = [...ids][0];
+    if (!mentioned.includes(identityId))
+      mentioned.push(identityId);
+  }
+  return mentioned;
+}
+var MonolithRoomTurnLoop = class {
   options;
   agent;
   reconciliationRequested = true;
@@ -20787,83 +20859,153 @@ var MonolithCornerTurnLoop = class {
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
   sessionFingerprint;
-  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
-  warmTranscript = new WarmTranscript();
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
   pinnedProviders = [];
-  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
-  modelTakesImages;
   /** The one provider re-pinned after an empty completion, until the session ends. */
   pinnedProviderOverride;
-  turnIdentityInstructions = "";
   busy = false;
-  forcedStop = false;
-  activityTail = Promise.resolve();
+  turnInstructionPrefix = "";
+  activeTurn;
+  queuedTurns = [];
+  continuityRebuildRequested = false;
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
-  /** The session's TMPDIR, where a granted command's script argument may also live. */
+  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
+  modelTakesImages;
+  /** The session's TMPDIR: writable to a granted command in a Room, as it is to the harness (C94). */
   sessionScratchDir;
-  /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
-  currentTurn;
+  /** The `agent-home.ts` overlay this session writes into; a Room grant keeps it. */
+  sessionStateDirs = [];
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
+  /** Local copies already delivered this session, by message id, so transcript renders reuse them. */
+  deliveredAttachments = /* @__PURE__ */ new Map();
+  /** Names from the latest roster read, for ledger bylines the runner writes. */
+  memberNames = /* @__PURE__ */ new Map();
+  /** The request id of the turn that paused on a grant card, until its decision arrives. */
+  pausedOnGrantRequestId;
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
-  memberNames = /* @__PURE__ */ new Map();
-  /** Agent identities in this Workspace, so a mention can be told from a human's. */
-  agentMembers = /* @__PURE__ */ new Set();
-  /** The member agent that answered in this corner last (`carriesCorner`). */
-  carrier;
-  /** The last server check state that started a turn; the same state never starts another. */
-  lastChecksState;
+  /** Per-sender continuity, shared in shape with corner intake. */
+  responseRule = new AgentResponseRule();
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
-    options.grantRunner?.register(options.cornerId, {
+    options.grantRunner?.register(options.roomId, {
       workspaceId: options.workspaceId,
-      cwd: options.worktreePath,
-      // A corner is the surface with `run-host-command`: its worktree becomes a
-      // branch and a pull request, and host work belongs here, next to the
-      // transcript that explains it. A granted command runs unwrapped (C94).
-      writePolicy: () => ({
-        surface: "corner",
-        ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {}
-      }),
-      turn: () => this.currentTurn
+      cwd: options.cwd,
+      // A top-level Room keeps its read-only promise for grants too: the runner
+      // wraps the command in this Room's own mount table (C94).
+      writePolicy: () => this.grantWritePolicy(),
+      turn: () => this.currentTurnForRunner()
     });
   }
   isBusy() {
     return this.busy;
   }
-  currentPrincipalCanDrive(_workspaceId, _principalId) {
-    return Promise.resolve(true);
-  }
-  refreshPersonaForSoulUpdate() {
-    return this.options.scheduler.suspend(this.options.cornerId);
-  }
-  async prepareForForcedUpdateRestart() {
-    this.forcedStop = true;
-  }
-  async forceRecoverRoom() {
-    if (this.client && this.sessionId)
-      this.client.sessionCancel(this.sessionId);
-    await this.options.scheduler.forceSuspend(this.options.cornerId);
-  }
-  async roster() {
-    const roster = await this.options.api.execute("getWorkspaceRoster", {
-      agentId: this.agent.publicKey,
-      workspaceId: this.options.workspaceId
-    });
-    this.memberNames = new Map(roster.members.map((member) => [member.identityId, member.name]));
-    this.agentMembers = new Set(roster.members.filter((member) => member.kind === "agent").map((member) => member.identityId));
-    return roster;
+  /** The turn a `request_grant` paused, if any (cleared when its decision resumes it). */
+  pausedGrantRequestId() {
+    return this.pausedOnGrantRequestId;
   }
   /**
-   * Drop this corner's live harness process. The next activation starts cold.
-   * A rotation is a fact about one live session, so the pin goes with it.
-   */
-  async discardSession() {
-    const client = this.client;
+   * What the grant runner may write here: the session's own scratch and home
+   * overlay and nothing else, enforced by the same read-only mount table the
+   * harness runs under. With no usable bwrap there is no way to keep that
+   * promise, so the policy carries no path and the runner refuses the run
+   * rather than widening the boundary.
+   */
+  grantWritePolicy() {
+    return {
+      surface: "room",
+      ...this.options.config.bwrapPath ? { bwrapPath: this.options.config.bwrapPath } : {},
+      ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {},
+      ...this.sessionStateDirs.length ? { harnessStateDirs: this.sessionStateDirs } : {},
+      maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, this.options.config.operatorHome ?? homedir6())
+    };
+  }
+  /**
+   * One turn's stopwatch. It is created for every turn — measuring is cheap —
+   * and only WRITES when the daemon configured a runtime directory to write
+   * into, so a standalone or test Body stays silent.
+   */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "room",
+      agentId: this.agent.publicKey,
+      roomId: this.options.roomId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+    });
+  }
+  currentTurnForRunner() {
+    const active = this.activeTurn;
+    if (!active)
+      return void 0;
+    return { requestId: active.item.id, requester: this.requesterOf(active.item.authorId) };
+  }
+  requesterOf(authorId) {
+    const name = this.memberNames.get(authorId);
+    return { pubkey: authorId, ...name ? { name } : {} };
+  }
+  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);
+  }
+  async prepareForForcedUpdateRestart() {
+  }
+  async forceRecoverRoom() {
+    if (this.client && this.sessionId)
+      this.client.sessionCancel(this.sessionId);
+    await this.options.scheduler.forceSuspend(this.options.roomId);
+  }
+  async roster() {
+    const roster = await this.options.api.execute("getWorkspaceRoster", {
+      agentId: this.agent.publicKey,
+      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;
+  }
+  /**
+   * Whether a picture actually reaches the model this session. Both halves
+   * have to hold (C87): the harness must advertise `promptCapabilities.image`,
+   * AND — when the pin knows the model's modalities — the model must take
+   * images. `undefined` modalities mean the question was never settled, and
+   * the harness answer stands alone as before.
+   */
+  acceptsImages() {
+    if (!(this.client?.canPromptWithImages() ?? false))
+      return false;
+    return this.modelTakesImages ?? true;
+  }
+  /** Download a message's attachments into the session scratch directory once. */
+  async deliver(item) {
+    if (!item.attachments.length || !this.attachmentDir)
+      return [];
+    const cached = this.deliveredAttachments.get(item.id);
+    if (cached)
+      return cached;
+    const delivered = await deliverAttachments(item.attachments, join5(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
+    this.deliveredAttachments.set(item.id, withoutImageData(delivered));
+    return delivered;
+  }
+  repositoryState() {
+    return this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId });
+  }
+  /**
+   * Drop this Room's live harness process. The next activation starts cold.
+   * A rotation is a fact about one live session, so the pin goes with it.
+   */
+  async discardSession() {
+    const client = this.client;
     this.client = void 0;
     this.sessionId = void 0;
     this.sessionFingerprint = void 0;
@@ -20871,8 +21013,14 @@ var MonolithCornerTurnLoop = class {
     if (client?.isAlive)
       await client.stop();
   }
-  /** See `MonolithRoomTurnLoop.sessionIsCurrent`: retention never keeps a
-   *  session whose persona or model pin the operator has since changed. */
+  /**
+   * Whether the retained session still matches the agent's server-side
+   * configuration. Retention (C104) is a saving only while what it keeps is
+   * still current, and a session's persona and model pin are fixed when it
+   * opens: they cannot be corrected in place, so a changed one has to cost a
+   * respawn. The check is one round trip — the roster half of which the turn
+   * was going to fetch anyway — against a cold spawn measured in seconds.
+   */
   async sessionIsCurrent() {
     return await this.currentSessionFingerprint() === this.sessionFingerprint;
   }
@@ -20880,7 +21028,7 @@ var MonolithCornerTurnLoop = class {
     const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.cornerId
+        roomId: this.options.roomId
       }),
       this.roster()
     ]);
@@ -20896,12 +21044,13 @@ var MonolithCornerTurnLoop = class {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
     trace?.noteActivation("cold");
-    const [configuration, roster] = await Promise.all([
+    const [configuration, roster, repositoryState] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.cornerId
+        roomId: this.options.roomId
       }),
-      this.roster()
+      this.roster(),
+      this.repositoryState()
     ]);
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const fingerprint = sessionConfigFingerprint({
@@ -20910,7 +21059,8 @@ var MonolithCornerTurnLoop = class {
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name
     });
-    await mkdir9(this.options.worktreePath, { recursive: true });
+    const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
+    await mkdir8(this.options.cwd, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
@@ -20927,26 +21077,7 @@ var MonolithCornerTurnLoop = class {
       })
     }) : {};
     const command = this.options.config.agentCommand ?? this.options.config.agentBinary;
-    const repository = this.options.repository;
-    let githubEnv = repository ? { GH_TOKEN: repository.githubToken, GITHUB_TOKEN: repository.githubToken } : {};
-    if (repository && this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
-      const gitBinary = (await execFileAsync3("which", ["git"])).stdout.trim();
-      const ghBinary = await execFileAsync3("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
-      githubEnv = await installCornerGitHubWrappers({
-        root: this.options.config.agentHomeRoot,
-        runtimeConfigPath: this.options.config.runtimeConfigPath,
-        roomId: this.options.parentRoomId,
-        cliEntrypoint: process.argv[1],
-        gitBinary,
-        ...ghBinary ? { ghBinary } : {},
-        inheritedPath: this.options.config.agentEnv.PATH ?? process.env.PATH
-      });
-    }
-    const agentEnv = {
-      ...this.options.config.agentEnv,
-      ...homeOverlay,
-      ...githubEnv
-    };
+    const agentEnv = { ...this.options.config.agentEnv, ...homeOverlay };
     this.agentEnv = agentEnv;
     const agentArgs = agentArgsWithModelSelection({
       kind: this.options.config.agentKind,
@@ -20957,19 +21088,17 @@ var MonolithCornerTurnLoop = class {
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
     this.attachmentDir = tmpDir ? join5(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
+    this.sessionStateDirs = stateDirs;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir9(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir8(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
     if (attachScratchRoot)
-      await mkdir9(attachScratchRoot, { recursive: true });
+      await mkdir8(attachScratchRoot, { recursive: true });
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
-        mode: "edit",
-        cwd: this.options.worktreePath,
-        worktreePath: this.options.worktreePath,
-        ...repository ? { gitCommonDir: repository.gitCommonDir } : {},
-        protectedPaths: [this.options.runtime.supervisorRoot],
+        mode: "readonly",
+        cwd: this.options.cwd,
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
         ...tmpDir ? { tmpDir } : {},
@@ -20979,41 +21108,18 @@ var MonolithCornerTurnLoop = class {
       command,
       args: agentArgs
     });
-    const clientOptions = {
-      agentCommand: spawnCommand.command,
-      agentArgs: spawnCommand.args,
-      agentEnv,
-      agentCwd: this.options.worktreePath,
-      agentLabel: command,
-      autoApprovePermissions: true,
-      permissionHandler: () => Promise.resolve("allow")
-    };
-    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
-    await this.client.start();
     const servers = [
-      ...repository ? [
-        {
-          name: "buzz-dev-mcp",
-          command: this.options.config.mcpBinary,
-          args: [],
-          // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
-          // This token is minted for this exact corner and is also the credential
-          // helper's password source, so its shell commands need the same scope as
-          // the corner harness without inheriting any host credentials.
-          env: [
-            { name: "GH_TOKEN", value: repository.githubToken },
-            { name: "GITHUB_TOKEN", value: repository.githubToken }
-          ]
-        }
-      ] : [],
+      readOnlyMcpServer(this.options.config, this.options.cwd),
       beelineAgentMcpServer(this.options.config, this.options.api, {
-        roomId: this.options.parentRoomId,
+        roomId: this.options.roomId,
         workspaceId: this.options.workspaceId,
-        cornerId: this.options.cornerId,
-        attachRoot: this.options.worktreePath,
-        // The whole per-session overlay, not an enumerated subset: see
-        // `monolith-room-turn.ts`'s matching comment.
+        attachRoot: this.options.cwd,
+        // The whole per-session overlay, not an enumerated subset: the agent
+        // never picks where a harness writes a file it generates (grok's own
+        // images dir, say), so anything inside the overlay it could possibly
+        // have written must be attachable, whatever subdirectory that is.
         attachScratchRoot,
+        directMessage,
         ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
       })
     ];
@@ -21022,38 +21128,43 @@ var MonolithCornerTurnLoop = class {
       piHome: agentEnv.PI_CODING_AGENT_DIR,
       servers
     });
+    const mountedServers = servers.map((server) => server.name);
+    const clientOptions = {
+      agentCommand: spawnCommand.command,
+      agentArgs: spawnCommand.args,
+      agentEnv,
+      agentCwd: this.options.cwd,
+      agentLabel: command,
+      // `bwrapPath` is set only when `detectBwrapSandbox` passed its self-test
+      // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
+      osSandbox: Boolean(this.options.config.bwrapPath),
+      autoApprovePermissions: false,
+      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
+    };
+    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
+    await this.client.start();
     const persona = configuration.soul ?? self?.soul;
-    const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
+    const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
-      ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
+      ...persona?.instructions ? [
+        `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
+        `Soul instructions: ${persona.instructions}`,
+        "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
+        "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
+      ] : [],
       SOUL_HOUSE_RULE
     ].join("\n");
-    this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
+    const repositoryInfo = repositoryState.resolution === "repository" && repositoryState.key ? {
+      name: repositoryState.key,
+      branch: repositoryState.targetBranch || "main"
+    } : void 0;
+    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo, directMessage);
+    this.turnInstructionPrefix = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions, capabilityContext.compatibilityTurnPrefix].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
-      cwd: this.options.worktreePath,
+      cwd: this.options.cwd,
       mcpServers: servers,
-      mode: "edit",
-      systemPrompt: [
-        identityInstructions,
-        personaInstructions,
-        ...repository ? [
-          `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
-          "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
-          `This corner is shared: any of its member agents may be addressed in it and work on ${repository.featureBranch}. Run git pull --rebase origin ${repository.featureBranch} before you push, and never force-push it.`,
-          "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
-          'Never merge because local tests pass or because gh reports passing checks. On a later turn triggered by a server-posted checks-passed note, call beeline-agent pr_checks_status. Merge only when it returns checks="passed", held=false, and approvalPending=false.',
-          "Merge the PR yourself only after the checks-passed event shows every check green; if any check failed or is still running, say exactly which and stop - never merge red.",
-          "If any human in this corner says hold or do not merge, do not merge until a later human explicitly resumes it.",
-          "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
-          'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
-          "A human approval in the app asks the server to merge. When approval is pending, wait for the server close request instead of racing it with gh. If checks passed, no hold exists, and no approval is pending, merge the pull request yourself with gh.",
-          "Never push directly to the target branch. Never merge a different pull request."
-        ] : [
-          "This is a chat-only corner with no repository or GitHub workflow.",
-          "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
-          "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
-        ]
-      ].filter(Boolean).join("\n\n")
+      mode: "readonly",
+      systemPrompt: [identityInstructions, personaInstructions, capabilityContext.sessionPrompt].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
     this.sessionFingerprint = fingerprint;
@@ -21063,7 +21174,12 @@ var MonolithCornerTurnLoop = class {
     }
     return opened.sessionId;
   }
-  /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
+  /**
+   * The scheduler seam, and the only place that can see the boundary between
+   * waiting for a slot and spawning a harness: `queue-wait` closes the instant
+   * `activate()` is called, and `cold` vs `warm` is decided by whether this
+   * Room already holds a live ACP client.
+   */
   lifecycle(trace) {
     return {
       activate: async () => {
@@ -21082,12 +21198,6 @@ var MonolithCornerTurnLoop = class {
       suspend: () => this.discardSession()
     };
   }
-  /** A picture reaches the model only if the harness AND the model take one (C87). */
-  acceptsImages() {
-    if (!(this.client?.canPromptWithImages() ?? false))
-      return false;
-    return this.modelTakesImages ?? true;
-  }
   /** The pinned providers a failure reason should name for this session. */
   servingProviders() {
     return this.pinnedProviderOverride ? [this.pinnedProviderOverride] : this.pinnedProviders;
@@ -21106,7 +21216,8 @@ var MonolithCornerTurnLoop = class {
   /**
    * Re-pin the session to the next provider in the OpenRouter order and open a
    * fresh session on it, so the retry of an empty completion is served — and
-   * named — by exactly one provider (C92).
+   * named — by exactly one provider. Undefined when the pin has nowhere left
+   * to go.
    */
   async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
@@ -21123,371 +21234,413 @@ var MonolithCornerTurnLoop = class {
     await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
-  /** One turn's stopwatch; writes only when the daemon configured a trace directory. */
-  beginTurnTrace(requestId) {
-    const directory = this.options.config.turnTraceDir;
-    if (directory)
-      this.turnTraceSink ??= new TurnTraceFile(directory);
-    return new TurnTrace({
-      surface: "corner",
-      agentId: this.agent.publicKey,
-      roomId: this.options.cornerId,
-      requestId,
-      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+  startPrompt(item) {
+    const active = {
+      item,
+      steers: [],
+      steerTail: Promise.resolve(),
+      resumeRequested: false,
+      cancelled: false,
+      phase: "prompting",
+      promise: Promise.resolve()
+    };
+    this.activeTurn = active;
+    active.promise = this.prompt(active).catch((error) => {
+      this.options.health.failure(1e3);
+      console.error(`[thin-core] monolith Room ${this.options.roomId} turn failed:`, error);
+    }).finally(() => {
+      if (this.activeTurn === active) {
+        this.activeTurn = void 0;
+        if (active.rebuildContinuity)
+          this.continuityRebuildRequested = true;
+        this.wakeIntake?.();
+        this.wakeIntake = void 0;
+      }
     });
   }
-  async prompt(requestId, trigger, attachments = [], requestedById, restates) {
-    const { api, cornerId } = this.options;
-    const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
-    const requester = requestedById ? {
-      pubkey: requestedById,
-      ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
-    } : void 0;
-    this.currentTurn = { requestId, ...requester ? { requester } : {} };
-    this.carrier = this.agent.publicKey;
-    const trace = this.beginTurnTrace(requestId);
+  /**
+   * Obey a stop the requester already made a fact.
+   *
+   * A stop names ONE request id and touches only the turn that answers it. The
+   * turn in flight is cancelled at the harness and marked so its own run
+   * publishes nothing; a turn still queued is simply dropped, since starting
+   * work the person has already withdrawn is worse than never starting it.
+   * A stop for neither is ignored — it belongs to a turn that ended between
+   * the press and the delivery, and the server's own receipt already said so.
+   */
+  stopTurn(requestId) {
+    for (let index = this.queuedTurns.length - 1; index >= 0; index -= 1)
+      if (this.queuedTurns[index].id === requestId)
+        this.queuedTurns.splice(index, 1);
+    const active = this.activeTurn;
+    if (!active || active.item.id !== requestId)
+      return;
+    active.cancelled = true;
+    if (this.client && this.sessionId)
+      this.client.sessionCancel(this.sessionId);
+  }
+  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;
+    this.busy = true;
+    const trace = this.beginTurnTrace(item.id);
     try {
+      if (!this.memberNames.has(item.authorId))
+        await this.roster().catch(() => void 0);
       await withTurnReceiptHeartbeat(api, {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
-        generationId: `${this.agent.publicKey}:${cornerId}`
-      }, () => {
+        roomId: this.options.roomId,
+        requestId: item.id,
+        generationId: `${this.agent.publicKey}:${this.options.roomId}`
+      }, async () => {
+        await api.execute("postAgentActivity", {
+          agentId: this.agent.publicKey,
+          roomId: this.options.roomId,
+          requestId: item.id,
+          activity: [
+            {
+              kind: "thinking",
+              title: "Working",
+              status: "in_progress",
+              requestedBy: this.requesterOf(item.authorId)
+            }
+          ]
+        });
         trace.noteScheduler("queue", this.options.scheduler.snapshot());
         trace.start("queue-wait");
-        return this.options.scheduler.run(cornerId, this.lifecycle(trace), async () => {
+        await this.options.scheduler.run(this.options.roomId, this.lifecycle(trace), async () => {
           trace.end("queue-wait");
           trace.noteScheduler("admission", this.options.scheduler.snapshot());
-          if (this.forcedStop)
-            throw new Error("corner turn stopped for daemon handoff");
-          this.busy = true;
-          await this.syncBranch();
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
-            api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
+            api.execute("getRoomConversation", { roomId: this.options.roomId, limit: 200 }),
             this.roster(),
-            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join5(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+            this.deliver(item)
           ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
-          const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
-          if (requestedBy)
-            this.currentTurn = { requestId, requester: requestedBy };
-          const transcriptRows = conversation.items.slice(-120).map((message) => ({
+          const transcriptRows = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => ({
             id: message.id,
-            line: `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`
+            line: roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())
           }));
+          const grantDecision = isGrantDecisionLine(item, this.agent.publicKey);
+          const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
+          if (grantDecision)
+            this.pausedOnGrantRequestId = void 0;
           const buildPrompt = () => [
-            this.turnIdentityInstructions,
-            `Corner objective:
-${this.options.objective}`,
-            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
+            this.turnInstructionPrefix,
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
+            `Newest message from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
+            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
+            grantDecision ? [
+              "This is the answer to your grant request; your paused work resumes now.",
+              "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
+              "If it was declined, try another way or say plainly what you cannot do."
+            ].join(" ") : "",
+            roomMentionDirectory(roster, this.agent.publicKey),
             [
-              `Newest trigger:
-${trigger}`,
-              ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
-            ].join("\n"),
-            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
-            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
+              "Write only the substantive Room message you want the human to read.",
+              "Do not repeat or paraphrase these instructions.",
+              "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
+              MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
+            ].join(" ")
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
             api,
             agentId: this.agent.publicKey,
-            roomId: cornerId,
-            requestId,
-            label: `corner ${cornerId}`
+            roomId: this.options.roomId,
+            requestId: item.id,
+            label: `monolith Room ${this.options.roomId}`
           });
-          const publishedToolCalls = /* @__PURE__ */ new Set();
-          const publishToolCalls = (calls, settledOnly) => {
-            calls.forEach((call, index) => {
-              const key = toolCallKey(call, index);
-              if (publishedToolCalls.has(key) || settledOnly && !toolCallSettled(call))
-                return;
-              publishedToolCalls.add(key);
-              this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
-                const activity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
-                await api.execute("postAgentActivity", {
-                  agentId: this.agent.publicKey,
-                  roomId: cornerId,
-                  requestId,
-                  activity: [activity]
-                });
-              }).then(() => void 0).catch((error) => {
-                publishedToolCalls.delete(key);
-                console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
-              });
-            });
-          };
           const runPrompt = async () => {
-            stream.beginRun();
-            trace.promptSent();
-            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full) => {
-              trace.firstModelOutput();
-              stream.onChunk(delta, full);
-            }, void 0, (calls) => {
-              trace.toolCalls(calls);
-              publishToolCalls(calls, true);
-            });
+            let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
+            let result2;
+            for (; ; ) {
+              let promptError;
+              try {
+                stream.beginRun();
+                trace.promptSent();
+                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
+                  trace.firstModelOutput();
+                  stream.onChunk(delta, full);
+                }, void 0, (calls) => trace.toolCalls(calls));
+              } catch (error) {
+                promptError = error;
+              }
+              const settledSteerTail = active.steerTail;
+              await settledSteerTail;
+              if (settledSteerTail !== active.steerTail)
+                continue;
+              if (!active.resumeRequested) {
+                if (promptError)
+                  throw promptError;
+                break;
+              }
+              active.resumeRequested = false;
+              nextPrompt = [
+                "The previous run was cancelled because its harness could not accept every live steer.",
+                "Resume the same turn. Keep the original request and everything that happened before it was cancelled.",
+                "Human messages that arrived after the original request, in transcript order:",
+                ...active.steers.map((steerItem) => roomMessagePrompt(steerItem.authorId.slice(0, 12), steerItem.body, steerItem.attachments, this.deliveredAttachments.get(steerItem.id), this.acceptsImages())),
+                "Continue now and answer the updated request without erasing the earlier context."
+              ].join("\n\n");
+            }
+            return result2;
           };
           let result = await runPrompt();
           trace.promptSettled();
           let explained = await this.explainEmpty(result);
-          if (explained && !restates && shouldRetryEmptyTurn(explained)) {
+          if (explained && shouldRetryEmptyTurn(explained)) {
             const silent = this.servingProviders();
             const next = await this.repinNextProvider(trace, explained.reason);
             if (next) {
-              console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
+              console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
               result = await runPrompt();
               trace.promptSettled();
               explained = await this.explainEmpty(result);
             }
           }
-          await this.activityTail;
-          publishToolCalls(result.toolCalls, false);
-          for (const call of result.toolCalls) {
+          if (active.cancelled) {
+            const stoppedText = durableReplyText(result.agentText);
+            await stream.settle(stoppedText, stoppedText ? { triggerMessageId: item.id } : {});
+            throw new TurnStoppedError("turn stopped by the requester");
+          }
+          active.phase = "finishing";
+          if (result.toolCalls.some((call) => pendingGrantToolCall(call))) {
+            this.pausedOnGrantRequestId = item.id;
+            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} paused on a grant card`);
+          } else if (resumedRequestId) {
+            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${resumedRequestId} resumed by grant decision ${item.id}`);
+          }
+          const openCornerCall = result.toolCalls.find((call) => /(?:^|[._:/-])open_corner$/i.test(call.title ?? ""));
+          if (openCornerCall) {
+            console.log(`[thin-core] monolith Room ${this.options.roomId} tool call: ${openCornerCall.title} (${openCornerCall.status ?? "no status"})`);
+            if (!isFailedToolCall(openCornerCall))
+              this.options.onCornerOpened?.();
+          }
+          for (const call of result?.toolCalls ?? []) {
             const failure = toolCallFailureLine(call);
-            if (failure)
-              console.warn(`[thin-core] corner ${cornerId} ${failure}`);
+            if (failure) {
+              console.warn(`[thin-core] monolith Room ${this.options.roomId} ${failure}`);
+            }
           }
-          await this.activityTail;
           stream.close();
           let reply = durableReplyText(result.agentText);
           if (!reply && explained) {
             reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
-            if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
+            if (!reply) {
               throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
             }
-            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
+            console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
           }
-          await trace.measure("publish", () => stream.settle(spoken(reply)));
-        }, { priority: "interactive", roomKey: cornerId });
-      }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
+          if (openCornerCall && !isFailedToolCall(openCornerCall)) {
+            reply = stripCornerOpenEcho(reply);
+          }
+          const mentionIds = reply ? agentReplyMentionIds(reply, roster, this.agent.publicKey) : [];
+          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", {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
+        roomId: this.options.roomId,
+        requestId: item.id,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${cornerId}`
+        generationId: `${this.agent.publicKey}:${this.options.roomId}`
       });
       await trace.finish("complete");
     } catch (error) {
+      if (error instanceof TurnStoppedError || active.cancelled) {
+        console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} stopped by the requester`);
+        await trace.finish("cancelled");
+        return;
+      }
       const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: cornerId,
-        requestId,
+        roomId: this.options.roomId,
+        requestId: item.id,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${cornerId}`,
+        generationId: `${this.agent.publicKey}:${this.options.roomId}`,
         reason
       });
       await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
-      this.currentTurn = void 0;
     }
   }
-  /** Whether this agent opened the corner. A corner with no recorded opener
-   *  behaves exactly as it did before members could carry it. */
-  isOpener() {
-    return !this.options.openedBy || this.options.openedBy === this.agent.publicKey;
-  }
-  /**
-   * Whether this agent is the one carrying the corner right now.
-   *
-   * Every member agent polls the corner, but its lifecycle — a server check
-   * note, a close request answered with work — is ONE fact and must start ONE
-   * turn, not one per member (the "one check turn per changed server state"
-   * rule). The carrier is whoever answered in the corner last, which is the
-   * opener until a human hands the work to someone else.
-   */
-  carriesCorner() {
-    return (this.carrier ?? this.options.openedBy ?? this.agent.publicKey) === this.agent.publicKey;
-  }
-  /** Notes an agent's durable message as the corner changing hands. */
-  noteCarrier(authorId) {
-    if (this.agentMembers.has(authorId))
-      this.carrier = authorId;
-  }
-  /**
-   * Whether a human message in this corner is addressed to THIS agent.
-   *
-   * A corner now runs like a Room — every member agent polls it — so an
-   * unrouted message would start one turn per member on one branch. A mention
-   * routes: the mentioned agent answers and nobody else. A message that names
-   * no agent at all keeps the old behaviour and falls to the opener, which is
-   * every single-agent corner ever opened.
-   */
-  async addressesThisAgent(item) {
-    if (item.mentionIds.includes(this.agent.publicKey))
-      return true;
-    if (!item.mentionIds.length)
-      return this.carriesCorner();
-    await this.roster().catch(() => void 0);
-    return item.mentionIds.some((id) => this.agentMembers.has(id)) ? false : this.carriesCorner();
-  }
-  /**
-   * Bring this worktree onto the corner's branch as GitHub currently has it,
-   * before any work is done on top of it.
-   *
-   * The branch is the shared artifact: another member agent may have pushed to
-   * it since this helper last looked, and a first touch of a corner this
-   * helper did not open starts from whatever `room-runtime.ts` restored. A
-   * divergence this cannot rebase away is raised, not pushed over — the turn
-   * fails with that sentence and the server inscribes it in the corner.
-   */
-  async syncBranch() {
-    const repository = this.options.repository;
-    if (!repository)
-      return;
-    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => repository.githubToken);
-    await syncCornerBranch({
-      worktreePath: this.options.worktreePath,
-      featureBranch: repository.featureBranch,
-      env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token, GIT_TERMINAL_PROMPT: "0" }
-    });
-  }
-  /** The server's check state for this head, or the notes' own verdict when the server carries none. */
-  async checksState(notes) {
-    try {
-      const restore = await this.options.api.execute("getCornerRestoreState", {
-        cornerId: this.options.cornerId
-      });
-      const fromServer = checksStateFromLifecycle(restore.lifecycle);
-      if (fromServer)
-        return fromServer;
-    } catch (error) {
-      console.error(`[thin-core] corner ${this.options.cornerId} check state read failed:`, error);
-    }
-    return notes.some((note) => completedCheckNote(note) === "failed") ? "failing" : "passing";
-  }
   async run() {
-    const { api, cornerId, signal } = this.options;
-    const activation = await api.execute("getRoomInbox", {
-      roomId: cornerId,
-      startAtLatest: true
-    });
-    let cursor3 = activation.cursor;
+    const { api, roomId, signal } = this.options;
+    let cursor3;
     const processedInboxIds = /* @__PURE__ */ new Set();
+    const deferredContinuity = /* @__PURE__ */ new Map();
     const pushedInbox = [];
     let pendingPushedCursor;
     let liveConnected = false;
-    const rewindSupported = Array.isArray(activation.rewindIds);
-    for (const id of activation.rewindIds ?? [])
-      processedInboxIds.add(id);
-    const stopLive = api.liveSubscribe?.(cornerId, cursor3, (items, pushedCursor) => {
-      pushedInbox.push(...items);
-      pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-      this.wakeIntake?.();
-      this.wakeIntake = void 0;
-    }, (connected, capabilities) => {
-      liveConnected = connected && capabilities?.pushIntake === true;
-      this.wakeIntake?.();
-      this.wakeIntake = void 0;
-    }, {
-      ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
-      ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
-      available: !this.options.config.modelUnavailable
-    });
-    const history = await api.execute("getRoomConversation", { roomId: cornerId, limit: 200 });
-    await this.roster().catch(() => void 0);
-    for (const item of history.items)
-      if (item.type === "message")
-        this.noteCarrier(item.authorId);
-    const durableAgentReplies = history.items.filter((item) => item.type === "message" && item.authorId === this.agent.publicKey && item.body.trim() !== this.options.objective.trim());
-    if (durableAgentReplies.length === 0 && this.isOpener()) {
-      await this.prompt(history.items.find((item) => item.requestId)?.requestId ?? cornerId.replaceAll("-", ""), this.options.objective);
-    }
+    let stopLive;
     try {
-      let pollWithoutWait = false;
+      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 {
-          const pollNow = pushedInbox.length > 0 || !liveConnected || this.reconciliationRequested;
-          const inbox = !pollNow ? { items: [], cursor: void 0, closeRequested: false } : await api.execute("getCornerCloseRequests", {
-            cornerId,
+          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 } : {}
+            ...rewindSupported ? { rewind: true } : {},
+            limit: 200
           });
           if (pollNow) {
             this.reconciliationRequested = false;
           }
-          if (inbox.closeRequested) {
-            await this.options.onCloseRequested();
-            return;
-          }
-          const checkNotes = [];
-          const delivered = [...pushedInbox.splice(0), ...inbox.items];
+          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))
+            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 > 1e4)
+            while (processedInboxIds.size > INBOX_DEDUPLICATION_LIMIT)
               processedInboxIds.delete(processedInboxIds.values().next().value);
-            if (item.type === "message") {
-              this.noteCarrier(item.authorId);
-              if (item.authorId === this.agent.publicKey)
-                continue;
-              if (!await this.addressesThisAgent(item))
-                continue;
+            const 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: cornerId,
+                roomId,
                 principalId: item.authorId
               });
-              if (!authority.member || authority.principalKind !== "human")
+              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;
             }
+            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?.(cornerId, cursor3);
+          api.updateLiveCursor?.(roomId, cursor3);
           if (pollNow)
-            this.options.onPoll();
-          await Promise.race([
-            wait(pollWithoutWait ? 0 : liveConnected ? 2147483647 : this.options.pollMs ?? cornerClosePollMs(), signal),
-            pushedInbox.length ? Promise.resolve() : new Promise((resolve30) => {
-              this.wakeIntake = resolve30;
-            })
-          ]);
-          pollWithoutWait = false;
+            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.onFailure(1e3);
-          console.error(`[thin-core] corner ${cornerId} turn loop failed:`, error);
+          this.options.health.failure(1e3);
+          console.error(`[thin-core] monolith Room ${roomId} turn loop failed:`, error);
           await wait(1e3, signal);
         }
       }
     } finally {
       stopLive?.();
       this.wakeIntake = void 0;
-      this.options.grantRunner?.unregister(cornerId);
-      await this.options.scheduler.suspend(cornerId);
+      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);
     }
   }
 };
+function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsImages = true) {
+  const message = body.trim() || "(shared attachments)";
+  const rendered = author ? `${author}: ${message}` : message;
+  return [rendered, ...attachmentPromptLines(attachments, delivered, harnessAcceptsImages)].join("\n");
+}
 async function wait(ms, signal) {
   if (signal?.aborted)
     return;
@@ -21502,137 +21655,191 @@ async function wait(ms, signal) {
   });
 }
 
-// apps/body/dist/monolith-room-turn.js
-import { mkdir as mkdir10 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { join as join6 } from "node:path";
-
-// packages/api-contract/dist/scheduled-prompts.js
-var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
-var SCHEDULE_RAN_VERB = "ran a schedule for";
-
-// apps/body/dist/monolith-room-turn.js
-function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
-  if (isSquireMcpPermissionRequest(request))
-    return false;
-  return isMountedMcpToolPermissionRequest(request, mountedServers);
+// 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: ""
+  };
 }
-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;
+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 isScheduledPrompt(item, agentId) {
-  if (item.type !== "system" || !item.mentionIds.includes(agentId))
-    return false;
-  if (item.systemEvent?.kind)
-    return item.systemEvent.kind === "schedule-ran";
-  return item.systemEvent?.verb === SCHEDULE_RAN_VERB;
+function 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'] });
 }
-function inboxItemAuthorName(item, agentId, names) {
-  if (isScheduledPrompt(item, agentId))
-    return SCHEDULE_SCHEDULER_NAME;
-  const subject = item.systemEvent?.subject;
-  if (item.type === "system" && subject?.name)
-    return subject.name;
-  return names.get(item.authorId) ?? item.authorId.slice(0, 12);
+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);
 }
-function inboxItemPromptBody(item, agentId) {
-  return isScheduledPrompt(item, agentId) ? item.systemEvent?.consequence ?? item.body : item.body;
+
+// apps/body/dist/monolith-corner-turn.js
+var execFileAsync3 = promisify3(execFile4);
+var TOOL_ARGUMENT_MAX_BYTES = 1200;
+var TOOL_OUTPUT_MAX_BYTES = 3200;
+var TOOL_PATH_LIMIT = 12;
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
 }
-function isSubscribedEvent(item, agentId) {
-  const kind = item.systemEvent?.kind;
-  return item.type === "system" && kind !== void 0 && !isResumeKind(kind) && item.mentionIds.includes(agentId);
+function serialized(value) {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
 }
-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 record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function isGrantDecisionLine(item, agentId) {
-  return item.type === "system" && item.mentionIds.includes(agentId) && parseGrantDecisionLine(item.body) !== void 0;
+function clampBytes(value, maxBytes) {
+  const clean4 = value.trim();
+  if (Buffer.byteLength(clean4) <= maxBytes)
+    return clean4;
+  const suffix = "\n\u2026[truncated]";
+  const allowed = maxBytes - Buffer.byteLength(suffix);
+  return `${Buffer.from(clean4).subarray(0, Math.max(0, allowed)).toString("utf8")}${suffix}`;
 }
-function inboxItemTriggersTurn(item, agentId) {
-  if (item.authorId === agentId)
-    return false;
-  if (!item.mentionIds.includes(agentId))
-    return false;
-  return item.type === "message" || isSubscribedEvent(item, agentId) || isScheduledPrompt(item, agentId) || isGrantDecisionLine(item, agentId);
+function outputExcerpt(value) {
+  const redacted = redactToolDetail(serialized(value));
+  if (!redacted.trim())
+    return void 0;
+  if (/\b(?:git[- ]credential|credential[- ]helper)\b/i.test(redacted)) {
+    return "Credential-helper output omitted.";
+  }
+  const lines = redacted.split(/\r?\n/).map((line) => line.trimEnd());
+  if (lines.length <= 8)
+    return clampBytes(lines.join("\n"), TOOL_OUTPUT_MAX_BYTES);
+  return clampBytes([...lines.slice(0, 4), "\u2026[output omitted]\u2026", ...lines.slice(-4)].join("\n"), TOOL_OUTPUT_MAX_BYTES);
 }
-function pendingGrantToolCall(call) {
-  if (!/(?:^|[._:/-])request_grant$/i.test(call.title ?? ""))
-    return false;
-  return /pending, card posted/i.test(typeof call.content === "string" ? call.content : JSON.stringify(call.content ?? ""));
+function filePaths(value, worktreePath) {
+  const paths = /* @__PURE__ */ new Set();
+  const visit = (candidate, key) => {
+    if (paths.size >= TOOL_PATH_LIMIT || candidate === null || candidate === void 0)
+      return;
+    if (typeof candidate === "string") {
+      if (key && /(?:^|_)(?:path|file|filename|target)$/i.test(key)) {
+        const path = candidate.startsWith(`${worktreePath}/`) ? candidate.slice(worktreePath.length + 1) : candidate;
+        if (path && path.length <= 512)
+          paths.add(redactToolDetail(path));
+      }
+      return;
+    }
+    if (Array.isArray(candidate)) {
+      candidate.forEach((entry) => visit(entry));
+      return;
+    }
+    const object = record(candidate);
+    if (object)
+      Object.entries(object).forEach(([entryKey, entry]) => visit(entry, entryKey));
+  };
+  visit(value);
+  return [...paths];
 }
-function roomMentionDirectory(roster, selfId) {
-  const rows = [];
-  for (const member of roster.members) {
-    if (member.identityId === selfId)
-      continue;
-    const handle = member.handle?.trim().replace(/^@/, "");
-    const name = member.name?.trim() ?? "";
-    const alias = handle || name;
-    if (!alias)
-      continue;
-    const kind = member.kind === "agent" ? "agent" : "person";
-    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
-  }
-  if (!rows.length)
-    return "";
-  return [
-    "Room members, and the exact spelling that tags each one:",
-    ...rows,
-    "Write a tag exactly as spelled here. An @name spelled any other way is plain text: it reaches nobody, and nobody is told it was meant for them. Never invent a handle, shorten one, or copy an @name out of the conversation \u2014 old messages carry spellings that no longer exist."
-  ].join("\n");
+function resultStatus(call) {
+  const content = record(call.content) ?? (typeof call.content === "string" ? (() => {
+    try {
+      return record(JSON.parse(call.content));
+    } catch {
+      return void 0;
+    }
+  })() : void 0);
+  const exitCode = content?.exitCode ?? content?.exit_code ?? content?.code;
+  if (typeof exitCode === "number" && Number.isFinite(exitCode))
+    return `exit ${exitCode}`;
+  if (content?.ok === true || content?.success === true)
+    return "ok";
+  if (content?.ok === false || content?.success === false)
+    return "error";
+  return /(?:failed|error|denied)/i.test(call.status ?? "") ? "error" : "ok";
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function toolArguments(call) {
+  const raw = record(call.rawInput);
+  const command = typeof call.rawInput === "string" ? call.rawInput : typeof raw?.command === "string" ? raw.command : typeof raw?.cmd === "string" ? raw.cmd : void 0;
+  if (command)
+    return { command: clampBytes(redactToolDetail(command), TOOL_ARGUMENT_MAX_BYTES) };
+  const input = serialized(call.rawInput);
+  return input ? { input: clampBytes(redactToolDetail(input), TOOL_ARGUMENT_MAX_BYTES) } : {};
 }
-function agentReplyMentionIds(text2, roster, authorId) {
-  const aliases = /* @__PURE__ */ new Map();
-  for (const member of roster.members) {
-    if (member.identityId === authorId)
-      continue;
-    for (const raw of [member.name, member.handle, member.soul?.name]) {
-      const display = raw?.trim().replace(/^@/, "");
-      if (!display)
-        continue;
-      const key = display.toLocaleLowerCase();
-      const entry = aliases.get(key) ?? { display, ids: /* @__PURE__ */ new Set() };
-      entry.ids.add(member.identityId);
-      aliases.set(key, entry);
+function toolCallKey(call, index) {
+  return call.id ? `id-${createHash4("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
+}
+function toolCallSettled(call) {
+  if (call.resultReceived)
+    return true;
+  return /^(?:completed|complete|failed|error|succeeded|success|passed|done)$/i.test(call.status ?? "");
+}
+function isSuccessfulCommit(call) {
+  if (/failed|error|denied/i.test(call.status ?? ""))
+    return false;
+  return /\bgit\s+commit\b|\bcommit(?:ted)?\s+(?:changes|files?)\b/i.test(`${call.title ?? ""} ${serialized(call.rawInput)}`);
+}
+async function cornerToolActivity(call, worktreePath, requestedBy) {
+  const operation = oneLine(call.kind ?? "") || "tool";
+  let title = oneLine(redactToolDetail(call.title ?? "")) || `${operation} tool`;
+  if (isSuccessfulCommit(call)) {
+    try {
+      const shown = await execFileAsync3("git", ["-C", worktreePath, "show", "--format=%s", "--name-only", "--no-renames", "HEAD"], { maxBuffer: 1024 * 1024 });
+      const lines = shown.stdout.split(/\r?\n/);
+      const subject = oneLine(lines.shift() ?? "commit");
+      const files = new Set(lines.map(oneLine).filter(Boolean));
+      title = `committed ${files.size} files: ${subject}`;
+    } catch {
     }
   }
-  for (const member of roster.members) {
-    if (member.identityId === authorId || !member.handle)
-      continue;
-    const handle = member.handle.trim().replace(/^@/, "").toLocaleLowerCase();
-    const canonical = aliases.get(handle);
-    const legacy = `a_${handle}`;
-    if (canonical && !aliases.has(legacy))
-      aliases.set(legacy, { ...canonical, display: legacy });
-  }
-  const mentioned = [];
-  for (const { display, ids } of [...aliases.values()].sort((left, right) => right.display.length - left.display.length)) {
-    if (ids.size !== 1)
-      continue;
-    const pattern = new RegExp(`(^|[\\s([{])@${escapeRegExp(display)}(?=$|[\\s.,!?;:)\\]}])`, "iu");
-    if (!pattern.test(text2))
-      continue;
-    const identityId = [...ids][0];
-    if (!mentioned.includes(identityId))
-      mentioned.push(identityId);
-  }
-  return mentioned;
+  const paths = filePaths([call.rawInput, call.content, call.locations], worktreePath);
+  const argumentsSummary = toolArguments(call);
+  const output = outputExcerpt(call.content);
+  return {
+    kind: "tool",
+    title: title.slice(0, 240),
+    operation: operation.slice(0, 80),
+    status: resultStatus(call),
+    ...argumentsSummary,
+    ...output ? { output } : {},
+    ...requestedBy ? { requestedBy } : {},
+    ...paths.length ? { files: paths.map((path) => ({ path })) } : {}
+  };
 }
-var MonolithRoomTurnLoop = class {
+var 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;
   agent;
   reconciliationRequested = true;
@@ -21647,108 +21854,95 @@ var MonolithRoomTurnLoop = class {
   sessionId;
   /** The configuration the live session baked in; a change invalidates it. */
   sessionFingerprint;
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
   pinnedProviders = [];
+  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
+  modelTakesImages;
   /** The one provider re-pinned after an empty completion, until the session ends. */
   pinnedProviderOverride;
+  turnIdentityInstructions = "";
   busy = false;
-  turnInstructionPrefix = "";
-  activeTurn;
-  queuedTurns = [];
+  forcedStop = false;
+  activityTail = Promise.resolve();
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
-  /** Whether the pinned model takes images; `undefined` when the pin did not say. */
-  modelTakesImages;
-  /** The session's TMPDIR: writable to a granted command in a Room, as it is to the harness (C94). */
+  /** The session's TMPDIR, where a granted command's script argument may also live. */
   sessionScratchDir;
-  /** The `agent-home.ts` overlay this session writes into; a Room grant keeps it. */
-  sessionStateDirs = [];
-  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
-  warmTranscript = new WarmTranscript();
-  /** Local copies already delivered this session, by message id, so transcript renders reuse them. */
-  deliveredAttachments = /* @__PURE__ */ new Map();
-  /** Names from the latest roster read, for ledger bylines the runner writes. */
-  memberNames = /* @__PURE__ */ new Map();
-  /** The request id of the turn that paused on a grant card, until its decision arrives. */
-  pausedOnGrantRequestId;
+  /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
+  currentTurn;
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
+  memberNames = /* @__PURE__ */ new Map();
+  /** Agent identities in this Workspace, so a mention can be told from a human's. */
+  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
+   * back here; ids that never matched a running turn are harmless and bounded
+   * by the same replay window the inbox already de-duplicates over.
+   */
+  stoppedTurns = /* @__PURE__ */ new Set();
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
-    options.grantRunner?.register(options.roomId, {
+    options.grantRunner?.register(options.cornerId, {
       workspaceId: options.workspaceId,
-      cwd: options.cwd,
-      // A top-level Room keeps its read-only promise for grants too: the runner
-      // wraps the command in this Room's own mount table (C94).
-      writePolicy: () => this.grantWritePolicy(),
-      turn: () => this.currentTurnForRunner()
+      cwd: options.worktreePath,
+      // A corner is the surface with `run-host-command`: its worktree becomes a
+      // branch and a pull request, and host work belongs here, next to the
+      // transcript that explains it. A granted command runs unwrapped (C94).
+      writePolicy: () => ({
+        surface: "corner",
+        ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {}
+      }),
+      turn: () => this.currentTurn
     });
   }
   isBusy() {
     return this.busy;
   }
-  /** The turn a `request_grant` paused, if any (cleared when its decision resumes it). */
-  pausedGrantRequestId() {
-    return this.pausedOnGrantRequestId;
-  }
-  /**
-   * What the grant runner may write here: the session's own scratch and home
-   * overlay and nothing else, enforced by the same read-only mount table the
-   * harness runs under. With no usable bwrap there is no way to keep that
-   * promise, so the policy carries no path and the runner refuses the run
-   * rather than widening the boundary.
-   */
-  grantWritePolicy() {
-    return {
-      surface: "room",
-      ...this.options.config.bwrapPath ? { bwrapPath: this.options.config.bwrapPath } : {},
-      ...this.sessionScratchDir ? { scratch: this.sessionScratchDir } : {},
-      ...this.sessionStateDirs.length ? { harnessStateDirs: this.sessionStateDirs } : {},
-      maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, this.options.config.operatorHome ?? homedir7())
-    };
-  }
-  /**
-   * One turn's stopwatch. It is created for every turn — measuring is cheap —
-   * and only WRITES when the daemon configured a runtime directory to write
-   * into, so a standalone or test Body stays silent.
-   */
-  beginTurnTrace(requestId) {
-    const directory = this.options.config.turnTraceDir;
-    if (directory)
-      this.turnTraceSink ??= new TurnTraceFile(directory);
-    return new TurnTrace({
-      surface: "room",
-      agentId: this.agent.publicKey,
-      roomId: this.options.roomId,
-      requestId,
-      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
-    });
-  }
-  currentTurnForRunner() {
-    const active = this.activeTurn;
-    if (!active)
-      return void 0;
-    return { requestId: active.item.id, requester: this.requesterOf(active.item.authorId) };
-  }
-  requesterOf(authorId) {
-    const name = this.memberNames.get(authorId);
-    return { pubkey: authorId, ...name ? { name } : {} };
-  }
-  currentPrincipalCanDrive(_workspaceId, principalId) {
-    return Promise.resolve(isSenderPermitted(this.options.config.accessPolicy ?? LEGACY_ACCESS_POLICY, principalId, this.options.config.accessOwnerPubkey, this.options.config.accessAllowlist));
+  currentPrincipalCanDrive(_workspaceId, _principalId) {
+    return Promise.resolve(true);
   }
-  async refreshPersonaForSoulUpdate() {
-    await this.options.scheduler.suspend(this.options.roomId);
+  refreshPersonaForSoulUpdate() {
+    return this.options.scheduler.suspend(this.options.cornerId);
   }
   async prepareForForcedUpdateRestart() {
+    this.forcedStop = true;
   }
   async forceRecoverRoom() {
     if (this.client && this.sessionId)
       this.client.sessionCancel(this.sessionId);
-    await this.options.scheduler.forceSuspend(this.options.roomId);
+    await this.options.scheduler.forceSuspend(this.options.cornerId);
+  }
+  /**
+   * Obey a stop the requester already made a fact.
+   *
+   * The id is remembered whether or not it names the turn in flight: a stop for
+   * work not yet started must still keep that work from starting, and one for a
+   * turn that has already ended is simply never read again. Only the session
+   * actually running the stopped turn is cancelled.
+   */
+  stopTurn(requestId) {
+    this.stoppedTurns.add(requestId);
+    while (this.stoppedTurns.size > 500)
+      this.stoppedTurns.delete(this.stoppedTurns.values().next().value);
+    if (this.currentTurn?.requestId !== requestId)
+      return;
+    if (this.client && this.sessionId)
+      this.client.sessionCancel(this.sessionId);
   }
   async roster() {
     const roster = await this.options.api.execute("getWorkspaceRoster", {
@@ -21756,36 +21950,17 @@ var MonolithRoomTurnLoop = 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;
   }
-  /**
-   * Whether a picture actually reaches the model this session. Both halves
-   * have to hold (C87): the harness must advertise `promptCapabilities.image`,
-   * AND — when the pin knows the model's modalities — the model must take
-   * images. `undefined` modalities mean the question was never settled, and
-   * the harness answer stands alone as before.
-   */
-  acceptsImages() {
-    if (!(this.client?.canPromptWithImages() ?? false))
-      return false;
-    return this.modelTakesImages ?? true;
-  }
-  /** Download a message's attachments into the session scratch directory once. */
-  async deliver(item) {
-    if (!item.attachments.length || !this.attachmentDir)
-      return [];
-    const cached = this.deliveredAttachments.get(item.id);
-    if (cached)
-      return cached;
-    const delivered = await deliverAttachments(item.attachments, join6(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
-    this.deliveredAttachments.set(item.id, withoutImageData(delivered));
-    return delivered;
-  }
-  repositoryState() {
-    return this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId });
+  async reconcileRoster() {
+    if (!this.rosterAvailable)
+      await this.roster().catch(() => void 0);
   }
   /**
-   * Drop this Room's live harness process. The next activation starts cold.
+   * Drop this corner's live harness process. The next activation starts cold.
    * A rotation is a fact about one live session, so the pin goes with it.
    */
   async discardSession() {
@@ -21797,14 +21972,8 @@ var MonolithRoomTurnLoop = class {
     if (client?.isAlive)
       await client.stop();
   }
-  /**
-   * Whether the retained session still matches the agent's server-side
-   * configuration. Retention (C104) is a saving only while what it keeps is
-   * still current, and a session's persona and model pin are fixed when it
-   * opens: they cannot be corrected in place, so a changed one has to cost a
-   * respawn. The check is one round trip — the roster half of which the turn
-   * was going to fetch anyway — against a cold spawn measured in seconds.
-   */
+  /** See `MonolithRoomTurnLoop.sessionIsCurrent`: retention never keeps a
+   *  session whose persona or model pin the operator has since changed. */
   async sessionIsCurrent() {
     return await this.currentSessionFingerprint() === this.sessionFingerprint;
   }
@@ -21812,7 +21981,7 @@ var MonolithRoomTurnLoop = class {
     const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId
+        roomId: this.options.cornerId
       }),
       this.roster()
     ]);
@@ -21828,13 +21997,12 @@ var MonolithRoomTurnLoop = class {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
     trace?.noteActivation("cold");
-    const [configuration, roster, repositoryState] = await Promise.all([
+    const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId
+        roomId: this.options.cornerId
       }),
-      this.roster(),
-      this.repositoryState()
+      this.roster()
     ]);
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const fingerprint = sessionConfigFingerprint({
@@ -21843,8 +22011,7 @@ var MonolithRoomTurnLoop = class {
       soul: configuration.soul ?? self?.soul,
       agentName: self?.name ?? this.agent.name
     });
-    const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
-    await mkdir10(this.options.cwd, { recursive: true });
+    await mkdir10(this.options.worktreePath, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
@@ -21861,7 +22028,26 @@ var MonolithRoomTurnLoop = class {
       })
     }) : {};
     const command = this.options.config.agentCommand ?? this.options.config.agentBinary;
-    const agentEnv = { ...this.options.config.agentEnv, ...homeOverlay };
+    const repository = this.options.repository;
+    let githubEnv = repository ? { GH_TOKEN: repository.githubToken, GITHUB_TOKEN: repository.githubToken } : {};
+    if (repository && this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
+      const gitBinary = (await execFileAsync3("which", ["git"])).stdout.trim();
+      const ghBinary = await execFileAsync3("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
+      githubEnv = await installCornerGitHubWrappers({
+        root: this.options.config.agentHomeRoot,
+        runtimeConfigPath: this.options.config.runtimeConfigPath,
+        roomId: this.options.parentRoomId,
+        cliEntrypoint: process.argv[1],
+        gitBinary,
+        ...ghBinary ? { ghBinary } : {},
+        inheritedPath: this.options.config.agentEnv.PATH ?? process.env.PATH
+      });
+    }
+    const agentEnv = {
+      ...this.options.config.agentEnv,
+      ...homeOverlay,
+      ...githubEnv
+    };
     this.agentEnv = agentEnv;
     const agentArgs = agentArgsWithModelSelection({
       kind: this.options.config.agentKind,
@@ -21872,7 +22058,6 @@ var MonolithRoomTurnLoop = class {
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
     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) => mkdir10(dir, { recursive: true })));
     const attachScratchRoot = this.options.config.agentHomeRoot ?? tmpDir;
@@ -21881,8 +22066,11 @@ var MonolithRoomTurnLoop = class {
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
-        mode: "readonly",
-        cwd: this.options.cwd,
+        mode: "edit",
+        cwd: this.options.worktreePath,
+        worktreePath: this.options.worktreePath,
+        ...repository ? { gitCommonDir: repository.gitCommonDir } : {},
+        protectedPaths: [this.options.runtime.supervisorRoot],
         harnessStateDirs: stateDirs,
         harnessHomeStateDirs: homeStateDirs,
         ...tmpDir ? { tmpDir } : {},
@@ -21892,18 +22080,41 @@ var MonolithRoomTurnLoop = class {
       command,
       args: agentArgs
     });
+    const clientOptions = {
+      agentCommand: spawnCommand.command,
+      agentArgs: spawnCommand.args,
+      agentEnv,
+      agentCwd: this.options.worktreePath,
+      agentLabel: command,
+      autoApprovePermissions: true,
+      permissionHandler: () => Promise.resolve("allow")
+    };
+    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
+    await this.client.start();
     const servers = [
-      readOnlyMcpServer(this.options.config, this.options.cwd),
+      ...repository ? [
+        {
+          name: "buzz-dev-mcp",
+          command: this.options.config.mcpBinary,
+          args: [],
+          // ACP hosts launch stdio MCP servers with an explicit, sanitized env.
+          // This token is minted for this exact corner and is also the credential
+          // helper's password source, so its shell commands need the same scope as
+          // the corner harness without inheriting any host credentials.
+          env: [
+            { name: "GH_TOKEN", value: repository.githubToken },
+            { name: "GITHUB_TOKEN", value: repository.githubToken }
+          ]
+        }
+      ] : [],
       beelineAgentMcpServer(this.options.config, this.options.api, {
-        roomId: this.options.roomId,
+        roomId: this.options.parentRoomId,
         workspaceId: this.options.workspaceId,
-        attachRoot: this.options.cwd,
-        // The whole per-session overlay, not an enumerated subset: the agent
-        // never picks where a harness writes a file it generates (grok's own
-        // images dir, say), so anything inside the overlay it could possibly
-        // have written must be attachable, whatever subdirectory that is.
+        cornerId: this.options.cornerId,
+        attachRoot: this.options.worktreePath,
+        // The whole per-session overlay, not an enumerated subset: see
+        // `monolith-room-turn.ts`'s matching comment.
         attachScratchRoot,
-        directMessage,
         ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
       })
     ];
@@ -21912,43 +22123,38 @@ var MonolithRoomTurnLoop = class {
       piHome: agentEnv.PI_CODING_AGENT_DIR,
       servers
     });
-    const mountedServers = servers.map((server) => server.name);
-    const clientOptions = {
-      agentCommand: spawnCommand.command,
-      agentArgs: spawnCommand.args,
-      agentEnv,
-      agentCwd: this.options.cwd,
-      agentLabel: command,
-      // `bwrapPath` is set only when `detectBwrapSandbox` passed its self-test
-      // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
-      osSandbox: Boolean(this.options.config.bwrapPath),
-      autoApprovePermissions: false,
-      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
-    };
-    this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
-    await this.client.start();
     const persona = configuration.soul ?? self?.soul;
-    const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
+    const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
-      ...persona?.instructions ? [
-        `Your human-authored identity and soul in this Workspace is ${persona.name}.`,
-        `Soul instructions: ${persona.instructions}`,
-        "This is who you are in this Workspace. Adopt it in your voice, self-description, and behavior.",
-        "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
-      ] : [],
+      ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
       SOUL_HOUSE_RULE
     ].join("\n");
-    const repositoryInfo = repositoryState.resolution === "repository" && repositoryState.key ? {
-      name: repositoryState.key,
-      branch: repositoryState.targetBranch || "main"
-    } : void 0;
-    const capabilityContext = beelineCapabilityContextForHarness(command, repositoryInfo, directMessage);
-    this.turnInstructionPrefix = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions, capabilityContext.compatibilityTurnPrefix].filter(Boolean).join("\n\n");
+    this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
-      cwd: this.options.cwd,
+      cwd: this.options.worktreePath,
       mcpServers: servers,
-      mode: "readonly",
-      systemPrompt: [identityInstructions, personaInstructions, capabilityContext.sessionPrompt].filter(Boolean).join("\n\n")
+      mode: "edit",
+      systemPrompt: [
+        identityInstructions,
+        personaInstructions,
+        ...repository ? [
+          `You are in an isolated git worktree on ${repository.featureBranch}, targeting ${repository.targetBranch}.`,
+          "Work normally with the full coding tools. Commit and push only this feature branch. Use gh to open its pull request.",
+          `This corner is shared: any of its member agents may be addressed in it and work on ${repository.featureBranch}. Run git pull --rebase origin ${repository.featureBranch} before you push, and never force-push it.`,
+          "PR-opening turn rule: as soon as a pull request exists, print its full GitHub URL as your final response and end the turn immediately. Do not call pr_checks_status in that same turn and do not wait for checks inside it. Then stay idle until a later corner fact or human message starts another turn.",
+          'Never merge because local tests pass or because gh reports passing checks. On a later turn triggered by a server-posted checks-passed note, call beeline-agent pr_checks_status. Merge only when it returns checks="passed", held=false, and approvalPending=false.',
+          "Merge the PR yourself only after the checks-passed event shows every check green; if any check failed or is still running, say exactly which and stop - never merge red.",
+          "If any human in this corner says hold or do not merge, do not merge until a later human explicitly resumes it.",
+          "Do not tag the user when a corner turn finishes: the server posts the merge summary card and its push already cover completion. Tag a human only mid-turn, and only when you need a decision or input.",
+          'GitHub check and merge notes are server lines already in the corner: never restate them (no "checks passed", "CI is green", "PR ready for review"). On a checks turn, say nothing unless you act - a merge or a pushed fix - and then one short line about that.',
+          "A human approval in the app asks the server to merge. When approval is pending, wait for the server close request instead of racing it with gh. If checks passed, no hold exists, and no approval is pending, merge the pull request yourself with gh.",
+          "Never push directly to the target branch. Never merge a different pull request."
+        ] : [
+          "This is a chat-only corner with no repository or GitHub workflow.",
+          "Work in this corner's writable workspace. Use write_scratch_file or ordinary tools to create files, then attach_file to send them back to the corner.",
+          "Do not initialize a repository, create a branch, push, open a pull request, or wait for GitHub checks."
+        ]
+      ].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
     this.sessionFingerprint = fingerprint;
@@ -21958,12 +22164,7 @@ var MonolithRoomTurnLoop = class {
     }
     return opened.sessionId;
   }
-  /**
-   * The scheduler seam, and the only place that can see the boundary between
-   * waiting for a slot and spawning a harness: `queue-wait` closes the instant
-   * `activate()` is called, and `cold` vs `warm` is decided by whether this
-   * Room already holds a live ACP client.
-   */
+  /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
   lifecycle(trace) {
     return {
       activate: async () => {
@@ -21982,6 +22183,12 @@ var MonolithRoomTurnLoop = class {
       suspend: () => this.discardSession()
     };
   }
+  /** A picture reaches the model only if the harness AND the model take one (C87). */
+  acceptsImages() {
+    if (!(this.client?.canPromptWithImages() ?? false))
+      return false;
+    return this.modelTakesImages ?? true;
+  }
   /** The pinned providers a failure reason should name for this session. */
   servingProviders() {
     return this.pinnedProviderOverride ? [this.pinnedProviderOverride] : this.pinnedProviders;
@@ -22000,8 +22207,7 @@ var MonolithRoomTurnLoop = class {
   /**
    * Re-pin the session to the next provider in the OpenRouter order and open a
    * fresh session on it, so the retry of an empty completion is served — and
-   * named — by exactly one provider. Undefined when the pin has nowhere left
-   * to go.
+   * named — by exactly one provider (C92).
    */
   async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
@@ -22018,330 +22224,495 @@ var MonolithRoomTurnLoop = class {
     await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
-  startPrompt(item) {
-    const active = {
-      item,
-      steers: [],
-      steerTail: Promise.resolve(),
-      resumeRequested: false,
-      phase: "prompting",
-      promise: Promise.resolve()
-    };
-    this.activeTurn = active;
-    active.promise = this.prompt(active).catch((error) => {
-      this.options.health.failure(1e3);
-      console.error(`[thin-core] monolith Room ${this.options.roomId} turn failed:`, error);
-    }).finally(() => {
-      if (this.activeTurn === active)
-        this.activeTurn = void 0;
-    });
-  }
-  steer(active, item) {
-    active.steers.push(item);
-    active.steerTail = active.steerTail.catch(() => void 0).then(async () => {
-      try {
-        const [roster, delivered] = await Promise.all([this.roster(), this.deliver(item)]);
-        const author = roster.members.find((member) => member.identityId === item.authorId)?.name ?? item.authorId.slice(0, 12);
-        await this.client.sessionSteer(this.sessionId, [
-          `Human steer received while the current turn is running from ${author}:`,
-          roomMessagePrompt("", item.body, item.attachments, delivered, this.acceptsImages()),
-          "Adjust the current work now. Keep the original request and earlier messages as context."
-        ].join("\n\n"));
-      } catch (error) {
-        active.resumeRequested = true;
-        this.client?.sessionCancel(this.sessionId);
-        console.warn(`[thin-core] monolith Room ${this.options.roomId} live steer unavailable; cancelling and resuming:`, error);
-      }
+  /** One turn's stopwatch; writes only when the daemon configured a trace directory. */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "corner",
+      agentId: this.agent.publicKey,
+      roomId: this.options.cornerId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
     });
   }
-  async prompt(active) {
-    const { item } = active;
-    const api = this.options.api;
-    this.busy = true;
-    const trace = this.beginTurnTrace(item.id);
+  async prompt(requestId, trigger, attachments = [], requestedById, restates) {
+    const { api, cornerId } = this.options;
+    if (this.stoppedTurns.has(requestId))
+      return;
+    const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
+    const requester = requestedById ? {
+      pubkey: requestedById,
+      ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
+    } : void 0;
+    this.currentTurn = { requestId, ...requester ? { requester } : {} };
+    this.carrier = this.agent.publicKey;
+    const trace = this.beginTurnTrace(requestId);
     try {
-      if (!this.memberNames.has(item.authorId))
-        await this.roster().catch(() => void 0);
       await withTurnReceiptHeartbeat(api, {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
-      }, async () => {
-        await api.execute("postAgentActivity", {
-          agentId: this.agent.publicKey,
-          roomId: this.options.roomId,
-          requestId: item.id,
-          activity: [
-            {
-              kind: "thinking",
-              title: "Working",
-              status: "in_progress",
-              requestedBy: this.requesterOf(item.authorId)
-            }
-          ]
-        });
+        roomId: cornerId,
+        requestId,
+        generationId: `${this.agent.publicKey}:${cornerId}`
+      }, () => {
         trace.noteScheduler("queue", this.options.scheduler.snapshot());
         trace.start("queue-wait");
-        await this.options.scheduler.run(this.options.roomId, this.lifecycle(trace), async () => {
+        return this.options.scheduler.run(cornerId, this.lifecycle(trace), async () => {
           trace.end("queue-wait");
           trace.noteScheduler("admission", this.options.scheduler.snapshot());
+          if (this.forcedStop)
+            throw new Error("corner turn stopped for daemon handoff");
+          this.busy = true;
+          await this.syncBranch();
           const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
-            api.execute("getRoomConversation", { roomId: this.options.roomId, limit: 200 }),
+            api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
             this.roster(),
-            this.deliver(item)
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join6(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
           ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
-          const transcriptRows = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => ({
+          const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
+          if (requestedBy)
+            this.currentTurn = { requestId, requester: requestedBy };
+          const transcriptRows = conversation.items.slice(-120).map((message) => ({
             id: message.id,
-            line: roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())
+            line: `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`
           }));
-          const grantDecision = isGrantDecisionLine(item, this.agent.publicKey);
-          const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
-          if (grantDecision)
-            this.pausedOnGrantRequestId = void 0;
           const buildPrompt = () => [
-            this.turnInstructionPrefix,
-            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
-            `Newest message from ${inboxItemAuthorName(item, this.agent.publicKey, names)}:`,
-            roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
-            grantDecision ? [
-              "This is the answer to your grant request; your paused work resumes now.",
-              "If it was approved and it is a command grant, run it with run_granted_command and the exact argv.",
-              "If it was declined, try another way or say plainly what you cannot do."
-            ].join(" ") : "",
-            roomMentionDirectory(roster, this.agent.publicKey),
+            this.turnIdentityInstructions,
+            `Corner objective:
+${this.options.objective}`,
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
             [
-              "Write only the substantive Room message you want the human to read.",
-              "Do not repeat or paraphrase these instructions.",
-              "If the newest message is only a nudge to respond, answer the most recent unanswered human message in the conversation instead of echoing the nudge.",
-              MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
-            ].join(" ")
+              `Newest trigger:
+${trigger}`,
+              ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
+            ].join("\n"),
+            this.options.repository ? "Continue the objective. Obey the PR checks and human hold rules in your session instructions." : "Continue the objective. Attach completed files before calling close_corner.",
+            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
           ].filter(Boolean).join("\n\n");
           const stream = new AgentTurnStream({
             api,
             agentId: this.agent.publicKey,
-            roomId: this.options.roomId,
-            requestId: item.id,
-            label: `monolith Room ${this.options.roomId}`
+            roomId: cornerId,
+            requestId,
+            label: `corner ${cornerId}`
           });
-          const runPrompt = async () => {
-            let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
-            let result2;
-            for (; ; ) {
-              let promptError;
-              try {
-                stream.beginRun();
-                trace.promptSent();
-                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
-                  trace.firstModelOutput();
-                  stream.onChunk(delta, full);
-                }, void 0, (calls) => trace.toolCalls(calls));
-              } catch (error) {
-                promptError = error;
+          let currentNarrationRun = "";
+          let completedNarrationRuns = [];
+          let narrationRunBoundary = 0;
+          const takeInterimNarration = () => {
+            const narration = spoken([...completedNarrationRuns, currentNarrationRun].map((run2) => spoken(durableReplyText(run2))).filter((run2) => run2 && !isPureRetryNarration(run2)).join("\n\n"));
+            narrationRunBoundary += completedNarrationRuns.length;
+            completedNarrationRuns = [];
+            currentNarrationRun = "";
+            return narration;
+          };
+          const publishedToolCalls = /* @__PURE__ */ new Set();
+          const observedToolCalls = /* @__PURE__ */ new Set();
+          const pendingToolNarrations = /* @__PURE__ */ new Map();
+          const pendingToolActivities = /* @__PURE__ */ new Map();
+          let lastNarratedToolCall;
+          let activityAttempt = 0;
+          const publishToolCalls = (calls, settledOnly) => {
+            calls.forEach((call, index) => {
+              const key = `${activityAttempt}:${toolCallKey(call, index)}`;
+              if (settledOnly && !observedToolCalls.has(key)) {
+                observedToolCalls.add(key);
+                const narration2 = takeInterimNarration();
+                pendingToolNarrations.set(key, narration2);
+                if (narration2)
+                  lastNarratedToolCall = key;
               }
-              const settledSteerTail = active.steerTail;
-              await settledSteerTail;
-              if (settledSteerTail !== active.steerTail)
-                continue;
-              if (!active.resumeRequested) {
-                if (promptError)
-                  throw promptError;
-                break;
+              if (settledOnly || publishedToolCalls.has(key) || !toolCallSettled(call))
+                return;
+              publishedToolCalls.add(key);
+              const narration = pendingToolNarrations.get(key) ?? "";
+              this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
+                let activity = pendingToolActivities.get(key);
+                if (!activity) {
+                  const toolActivity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
+                  activity = [
+                    ...narration ? [
+                      {
+                        kind: "output",
+                        title: "Update",
+                        text: narration,
+                        ...requestedBy ? { requestedBy } : {}
+                      }
+                    ] : [],
+                    toolActivity
+                  ];
+                  pendingToolActivities.set(key, activity);
+                }
+                await api.execute("postAgentActivity", {
+                  agentId: this.agent.publicKey,
+                  roomId: cornerId,
+                  requestId,
+                  cornerActivityKey: key,
+                  activity
+                });
+                pendingToolNarrations.delete(key);
+                pendingToolActivities.delete(key);
+              }).then(() => void 0).catch((error) => {
+                publishedToolCalls.delete(key);
+                console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
+              });
+            });
+          };
+          const flushToolCalls = async (calls, finalReply) => {
+            await this.activityTail;
+            if (lastNarratedToolCall && pendingToolNarrations.get(lastNarratedToolCall) === finalReply)
+              pendingToolNarrations.delete(lastNarratedToolCall);
+            publishToolCalls(calls, false);
+            await this.activityTail;
+            publishToolCalls(calls, false);
+            await this.activityTail;
+          };
+          const runPrompt = async () => {
+            activityAttempt += 1;
+            publishedToolCalls.clear();
+            observedToolCalls.clear();
+            pendingToolNarrations.clear();
+            pendingToolActivities.clear();
+            lastNarratedToolCall = void 0;
+            stream.beginRun();
+            completedNarrationRuns = [];
+            narrationRunBoundary = 0;
+            currentNarrationRun = "";
+            trace.promptSent();
+            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full, currentRun, runs) => {
+              trace.firstModelOutput();
+              if (runs) {
+                completedNarrationRuns = runs.slice(narrationRunBoundary);
+                currentNarrationRun = "";
+              } else if (currentRun === void 0)
+                currentNarrationRun += delta;
+              else {
+                if (currentNarrationRun && currentNarrationRun !== currentRun && !currentRun.startsWith(currentNarrationRun))
+                  completedNarrationRuns.push(currentNarrationRun);
+                currentNarrationRun = currentRun;
               }
-              active.resumeRequested = false;
-              nextPrompt = [
-                "The previous run was cancelled because its harness could not accept every live steer.",
-                "Resume the same turn. Keep the original request and everything that happened before it was cancelled.",
-                "Human messages that arrived after the original request, in transcript order:",
-                ...active.steers.map((steerItem) => roomMessagePrompt(steerItem.authorId.slice(0, 12), steerItem.body, steerItem.attachments, this.deliveredAttachments.get(steerItem.id), this.acceptsImages())),
-                "Continue now and answer the updated request without erasing the earlier context."
-              ].join("\n\n");
-            }
-            return result2;
+              stream.onChunk(delta, full);
+            }, void 0, (calls) => {
+              trace.toolCalls(calls);
+              publishToolCalls(calls, true);
+            });
           };
           let result = await runPrompt();
           trace.promptSettled();
           let explained = await this.explainEmpty(result);
-          if (explained && shouldRetryEmptyTurn(explained)) {
+          if (explained && !restates && shouldRetryEmptyTurn(explained)) {
+            await flushToolCalls(result.toolCalls, "");
             const silent = this.servingProviders();
             const next = await this.repinNextProvider(trace, explained.reason);
             if (next) {
-              console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
+              console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
               result = await runPrompt();
-              trace.promptSettled();
-              explained = await this.explainEmpty(result);
-            }
-          }
-          active.phase = "finishing";
-          if (result.toolCalls.some((call) => pendingGrantToolCall(call))) {
-            this.pausedOnGrantRequestId = item.id;
-            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id} paused on a grant card`);
-          } else if (resumedRequestId) {
-            console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${resumedRequestId} resumed by grant decision ${item.id}`);
-          }
-          const openCornerCall = result.toolCalls.find((call) => /(?:^|[._:/-])open_corner$/i.test(call.title ?? ""));
-          if (openCornerCall) {
-            console.log(`[thin-core] monolith Room ${this.options.roomId} tool call: ${openCornerCall.title} (${openCornerCall.status ?? "no status"})`);
-            if (!isFailedToolCall(openCornerCall))
-              this.options.onCornerOpened?.();
+              trace.promptSettled();
+              explained = await this.explainEmpty(result);
+            }
           }
-          for (const call of result?.toolCalls ?? []) {
+          if (this.stoppedTurns.has(requestId)) {
+            const stoppedText = spoken(durableReplyText(result.agentText));
+            await flushToolCalls(result.toolCalls, stoppedText);
+            await stream.settle(stoppedText);
+            throw new TurnStoppedError("turn stopped by the requester");
+          }
+          let reply = durableReplyText(result.agentText);
+          if (!reply && explained?.recoveredText)
+            reply = durableReplyText(explained.recoveredText);
+          await flushToolCalls(result.toolCalls, reply);
+          for (const call of result.toolCalls) {
             const failure = toolCallFailureLine(call);
-            if (failure) {
-              console.warn(`[thin-core] monolith Room ${this.options.roomId} ${failure}`);
-            }
+            if (failure)
+              console.warn(`[thin-core] corner ${cornerId} ${failure}`);
           }
           stream.close();
-          let reply = durableReplyText(result.agentText);
           if (!reply && explained) {
-            reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
-            if (!reply) {
+            if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
               throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
             }
-            console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${explained.reason}`);
-          }
-          if (openCornerCall && !isFailedToolCall(openCornerCall)) {
-            reply = stripCornerOpenEcho(reply);
+            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
           }
-          await trace.measure("publish", () => stream.settle(reply, reply ? {
-            triggerMessageId: item.id,
-            mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
-          } : {}));
-        }, { priority: "interactive", roomKey: this.options.roomId });
-      }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
+          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));
+        }, { priority: "interactive", roomKey: cornerId });
+      }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
+        roomId: cornerId,
+        requestId,
         status: "complete",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`
+        generationId: `${this.agent.publicKey}:${cornerId}`
       });
       await trace.finish("complete");
     } catch (error) {
+      if (error instanceof TurnStoppedError || this.stoppedTurns.has(requestId)) {
+        console.log(`[thin-core] corner ${cornerId} turn ${requestId} stopped by the requester`);
+        await trace.finish("cancelled");
+        return;
+      }
       const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
-        roomId: this.options.roomId,
-        requestId: item.id,
+        roomId: cornerId,
+        requestId,
         status: "failed",
-        generationId: `${this.agent.publicKey}:${this.options.roomId}`,
+        generationId: `${this.agent.publicKey}:${cornerId}`,
         reason
       });
       await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
+      this.currentTurn = void 0;
+    }
+  }
+  /** Whether this agent opened the corner. A corner with no recorded opener
+   *  behaves exactly as it did before members could carry it. */
+  isOpener() {
+    return !this.options.openedBy || this.options.openedBy === this.agent.publicKey;
+  }
+  /**
+   * Whether this agent is the one carrying the corner right now.
+   *
+   * Every member agent polls the corner, but its lifecycle — a server check
+   * note, a close request answered with work — is ONE fact and must start ONE
+   * turn, not one per member (the "one check turn per changed server state"
+   * rule). The carrier is whoever answered in the corner last, which is the
+   * opener until a human hands the work to someone else.
+   */
+  carriesCorner() {
+    return (this.carrier ?? this.options.openedBy ?? this.agent.publicKey) === this.agent.publicKey;
+  }
+  /** Notes an agent's durable message as the corner changing hands. */
+  noteCarrier(authorId) {
+    if (this.agentMembers.has(authorId))
+      this.carrier = authorId;
+  }
+  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.
+   *
+   * The branch is the shared artifact: another member agent may have pushed to
+   * it since this helper last looked, and a first touch of a corner this
+   * helper did not open starts from whatever `room-runtime.ts` restored. A
+   * divergence this cannot rebase away is raised, not pushed over — the turn
+   * fails with that sentence and the server inscribes it in the corner.
+   */
+  async syncBranch() {
+    const repository = this.options.repository;
+    if (!repository)
+      return;
+    const token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => repository.githubToken);
+    await syncCornerBranch({
+      worktreePath: this.options.worktreePath,
+      featureBranch: repository.featureBranch,
+      env: { ...process.env, GH_TOKEN: token, GITHUB_TOKEN: token, GIT_TERMINAL_PROMPT: "0" }
+    });
+  }
+  /** The server's check state for this head, or the notes' own verdict when the server carries none. */
+  async checksState(notes) {
+    try {
+      const restore = await this.options.api.execute("getCornerRestoreState", {
+        cornerId: this.options.cornerId
+      });
+      const fromServer = checksStateFromLifecycle(restore.lifecycle);
+      if (fromServer)
+        return fromServer;
+    } catch (error) {
+      console.error(`[thin-core] corner ${this.options.cornerId} check state read failed:`, error);
     }
+    return notes.some((note) => completedCheckNote(note) === "failed") ? "failing" : "passing";
   }
   async run() {
-    const { api, roomId, signal } = this.options;
-    let cursor3;
+    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;
-    let stopLive;
+    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 {
-      const activation = await api.execute("getRoomInbox", { roomId, startAtLatest: true });
-      cursor3 = activation.cursor;
-      const rewindSupported = Array.isArray(activation.rewindIds);
-      for (const id of activation.rewindIds ?? [])
-        processedInboxIds.add(id);
-      stopLive = api.liveSubscribe?.(roomId, cursor3, (items, pushedCursor) => {
-        pushedInbox.push(...items);
-        pendingPushedCursor = laterInboxCursor(pendingPushedCursor, pushedCursor);
-        this.wakeIntake?.();
-        this.wakeIntake = void 0;
-      }, (connected, capabilities) => {
-        liveConnected = connected && capabilities?.pushIntake === true;
-        this.options.health.presence(connected && !this.options.config.modelUnavailable ? "online" : "offline");
-        this.wakeIntake?.();
-        this.wakeIntake = void 0;
-      }, {
-        ...this.options.config.daemonReleaseVersion ? { releaseVersion: this.options.config.daemonReleaseVersion } : {},
-        ...this.options.config.daemonSourceSha ? { sourceSha: this.options.config.daemonSourceSha } : {},
-        available: !this.options.config.modelUnavailable
-      });
+      let pollWithoutWait = false;
       while (!signal?.aborted) {
         try {
-          if (!this.activeTurn && this.queuedTurns.length) {
-            this.startPrompt(this.queuedTurns.shift());
+          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 } : await api.execute("getRoomInbox", {
-            roomId,
+          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 } : {},
-            limit: 200
+            ...rewindSupported ? { rewind: true } : {}
           });
           if (pollNow) {
             this.reconciliationRequested = false;
           }
-          const delivered = [...pushedInbox.splice(0), ...inbox.items];
+          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 > 1e4)
+            while (processedInboxIds.size > INBOX_DEDUPLICATION_LIMIT)
               processedInboxIds.delete(processedInboxIds.values().next().value);
-            if (!inboxItemTriggersTurn(item, this.agent.publicKey))
+            const stoppedTurn = turnStopRequestId(item, this.agent.publicKey);
+            if (stoppedTurn) {
+              this.stopTurn(stoppedTurn);
               continue;
-            if (!inboxItemSkipsSenderPolicy(item, this.agent.publicKey)) {
+            }
+            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,
+                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;
             }
-            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);
+          api.updateLiveCursor?.(cornerId, cursor3);
           if (pollNow)
-            this.options.health.poll();
-          if (!pushedInbox.length) {
-            await Promise.race([
-              wait2(liveConnected ? 2147483647 : this.options.pollMs ?? 1e3, signal),
-              new Promise((resolve30) => {
-                this.wakeIntake = resolve30;
-              })
-            ]);
-          }
+            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.health.failure(1e3);
-          console.error(`[thin-core] monolith Room ${roomId} turn loop failed:`, error);
+          this.options.onFailure(1e3);
+          console.error(`[thin-core] corner ${cornerId} turn loop failed:`, error);
           await wait2(1e3, signal);
         }
       }
     } finally {
       stopLive?.();
       this.wakeIntake = void 0;
-      this.options.grantRunner?.unregister(roomId);
-      if (this.activeTurn?.phase === "prompting" && this.client && this.sessionId) {
-        this.client.sessionCancel(this.sessionId);
-      }
-      await this.activeTurn?.promise;
-      await this.options.scheduler.suspend(roomId);
+      this.options.grantRunner?.unregister(cornerId);
+      await this.options.scheduler.suspend(cornerId);
     }
   }
 };
-function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsImages = true) {
-  const message = body.trim() || "(shared attachments)";
-  const rendered = author ? `${author}: ${message}` : message;
-  return [rendered, ...attachmentPromptLines(attachments, delivered, harnessAcceptsImages)].join("\n");
-}
 async function wait2(ms, signal) {
   if (signal?.aborted)
     return;
@@ -22771,7 +23142,7 @@ function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
 }
 async function materializeCornerWorktree(input) {
   const remote = roomCheckoutRemote(input.remote);
-  const repositoryHash = createHash4("sha256").update(remote).digest("hex").slice(0, 24);
+  const repositoryHash = createHash5("sha256").update(remote).digest("hex").slice(0, 24);
   const gitCommonDir = resolve19(input.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
   const path = resolve19(input.supervisorRoot, "beeline", "corners", input.cornerId);
   await mkdir11(dirname6(gitCommonDir), { recursive: true, mode: 448 });
@@ -23140,7 +23511,7 @@ var RoomRuntimeCoordinator = class {
       return this.roomRoot(roomId);
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
-    const checkoutId = createHash4("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
+    const checkoutId = createHash5("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
     const path = resolve19(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
     await mkdir11(dirname6(path), { recursive: true, mode: 448 });
     const token = remote.startsWith("https://github.com/") ? await this.options.daemonApi.execute("getRoomGitHubToken", { roomId }) : void 0;
@@ -23752,7 +24123,7 @@ async function runStartCommand(args, interactiveUi) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
+import { 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 { stdin as stdin3, stdout as stdout4 } from "node:process";
@@ -24328,7 +24699,7 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
-  const avatarSeed = createHash6("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
+  const avatarSeed = createHash7("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
   return jsonRequest(`${baseUrl}/auth/agent/connect`, {
     pairing_code: normalizedPairingCode,
     harness: selection.harness,
@@ -26154,10 +26525,7 @@ async function main() {
     await repairInstallForwarders(startupLayout).catch(() => void 0);
   }
   const interactiveUi = command !== "daemon" && Boolean(stdin4.isTTY && stdout5.isTTY);
-  const llmEnvFile = process.env.BUZZY_BODY_LLM_FILE;
-  const workspaceRoot = process.env.BUZZY_BODY_WORKSPACE ?? "./body-workspace";
   if (command === "--version" || command === "version") {
-    const config = loadBodyConfig({ workspaceRoot, llmEnvFile });
     console.log(import_picocolors3.default.bold("beeline 0.0.0"));
     const layout = beelineInstallLayout(process.env);
     if (layout) {
@@ -26165,9 +26533,6 @@ async function main() {
       const active = await activeReleaseId(layout);
       console.log(`${import_picocolors3.default.dim("installed bundle:")} ${describeIdentity(identity)}${active ? ` (release ${active})` : ""}`);
     }
-    console.log(`${import_picocolors3.default.dim("[body] agent binary:")} ${config.agentCommand ?? config.agentBinary}`);
-    console.log(`${import_picocolors3.default.dim("[body] mcp binary:")} ${config.mcpBinary}`);
-    console.log(`${import_picocolors3.default.dim("[body] read-only mcp:")} ${config.readonlyMcpCommand}`);
     return;
   }
   if (command === "daemon") {