usebeeline 0.0.53 → 0.0.56

package/dist/usebeeline.mjs

@@ -955,8 +955,8 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname15, resolve as resolve28 } from "node:path";
-import { readFile as readFile14, unlink as unlink3, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve29 } from "node:path";
+import { readFile as readFile14, unlink as unlink5, writeFile as writeFile15 } from "node:fs/promises";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -2951,13 +2951,17 @@ function parseSandboxMaskEnv(env) {
   return entries.length ? entries : void 0;
 }
 
-// apps/body/dist/access-policy.js
+// packages/api-contract/dist/agent-access.js
 var AGENT_ACCESS_POLICIES = ["everyone", "creator", "allowlist"];
-var DEFAULT_ACCESS_POLICY = "creator";
-var LEGACY_ACCESS_POLICY = "everyone";
+var DEFAULT_AGENT_ACCESS_POLICY = "everyone";
 function isAgentAccessPolicy(value) {
   return AGENT_ACCESS_POLICIES.includes(value);
 }
+var ACCESS_NOTICE_WINDOW_MS = 10 * 6e4;
+
+// apps/body/dist/access-policy.js
+var DEFAULT_ACCESS_POLICY = DEFAULT_AGENT_ACCESS_POLICY;
+var LEGACY_ACCESS_POLICY = "everyone";
 var ACCESS_REFUSAL_WINDOW_MS = 60 * 60 * 1e3;
 function isSenderPermitted(policy, senderPubkey, ownerPubkey, allowlist = void 0) {
   if (!senderPubkey)
@@ -3832,7 +3836,7 @@ var AcpClient = class extends EventEmitter {
     const current = this.activeRunIds.get(sessionId);
     if (current)
       return Promise.resolve(current);
-    return new Promise((resolve29, reject) => {
+    return new Promise((resolve30, reject) => {
       const onUpdate = (update) => {
         if (update.sessionId !== sessionId)
           return;
@@ -3840,7 +3844,7 @@ var AcpClient = class extends EventEmitter {
         if (!runId)
           return;
         cleanup();
-        resolve29(runId);
+        resolve30(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -3924,13 +3928,13 @@ var AcpClient = class extends EventEmitter {
     }
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve29, reject) => {
+    return new Promise((resolve30, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart), detail));
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: resolve29,
+        resolve: resolve30,
         reject,
         timer,
         method,
@@ -13280,12 +13284,12 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 }
 
 // apps/body/dist/room-runtime.js
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
 import { mkdir as mkdir11, rm as rm4 } from "node:fs/promises";
 import { dirname as dirname6, resolve as resolve19 } from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { promisify as promisify4 } from "node:util";
 
 // apps/body/dist/grant-runner.js
 import { execFile as execFile2 } from "node:child_process";
@@ -14125,11 +14129,11 @@ var GrantRunnerServer = class {
 };
 
 // apps/body/dist/monolith-corner-turn.js
-import { execFile as execFile3 } from "node:child_process";
+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 { promisify as promisify2 } from "node:util";
+import { promisify as promisify3 } from "node:util";
 
 // apps/body/dist/agent-home.js
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
@@ -14177,7 +14181,7 @@ function isAgentPairingCode(value) {
 var USING_BEELINE_SKILL_NAME = "using-beeline";
 var BEELINE_ROOM_CAPABILITIES = [
   "The repository filesystem is read-only in this Room session.",
-  "You may address any Room member, including another agent, by writing @name in your reply; the server routes that mention to them.",
+  "You may address any Room member, including another agent, by writing @name in your reply; the server routes that mention to them. Each turn prompt lists the Room members and the exact spelling that tags each one - use those spellings, and never guess or reuse one from an older message.",
   "Tag another agent only when you need something from them: a question, a handoff, a task. Never tag to acknowledge, agree, or say you are ready. If nothing is actionable, do not reply.",
   "Tag the user only when you need a decision or input, or when the task they asked for is finished. Never tag for progress, acknowledgement, or questions the transcript already answers.",
   "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
@@ -15355,6 +15359,8 @@ function harnessStateDirsFromEnv(env) {
 import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
 import { basename as basename4, extname, join as join4 } from "node:path";
 var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+var MEDIA_TTL_HOURS = 24;
+var EXPIRED_REASON = `expired: attachments are kept for ${MEDIA_TTL_HOURS} hours and these bytes are past that window`;
 var FETCH_TIMEOUT_MS = 3e4;
 var MAX_INLINE_IMAGE_BYTES = 5 * 1024 * 1024;
 function safeFileName(attachment, index, taken) {
@@ -15379,10 +15385,14 @@ async function deliverAttachments(attachments, dir, fetchImpl = fetch) {
     });
     if (attachment.size && attachment.size > MAX_ATTACHMENT_BYTES)
       return tooLarge(attachment.size);
+    if (attachment.expired)
+      return { attachment, reason: EXPIRED_REASON };
     try {
       const response = await fetchImpl(attachment.url, {
         signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
       });
+      if (response.status === 410)
+        return { attachment, reason: EXPIRED_REASON };
       if (!response.ok)
         throw new Error(`HTTP ${response.status}`);
       const declared = Number(response.headers.get("content-length") ?? 0);
@@ -15925,6 +15935,55 @@ export default async function (pi) {
 }
 `;
 
+// apps/body/dist/corner-branch-sync.js
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile3);
+var CornerBranchDivergedError = class extends Error {
+  name = "CornerBranchDivergedError";
+};
+async function syncCornerBranch(input) {
+  const git = input.git ?? (async (args) => (await execFileAsync2("git", ["-C", input.worktreePath, ...args], {
+    ...input.env ? { env: input.env } : {},
+    maxBuffer: 4 * 1024 * 1024
+  })).stdout);
+  const remoteRef = `refs/remotes/origin/${input.featureBranch}`;
+  const fetched = await git([
+    "fetch",
+    "origin",
+    `+refs/heads/${input.featureBranch}:${remoteRef}`
+  ]).then(() => true, () => false);
+  if (!fetched)
+    return "unchanged";
+  const remote = await git(["rev-parse", remoteRef]).then((value) => value.trim(), () => "");
+  if (!remote)
+    return "unchanged";
+  const local = (await git(["rev-parse", "HEAD"])).trim();
+  if (local === remote)
+    return "unchanged";
+  if (await contains(git, local, remote))
+    return "unchanged";
+  const behind = await contains(git, remote, local);
+  try {
+    await git(behind ? ["merge", "--ff-only", remote] : ["rebase", remote]);
+    return behind ? "fast-forwarded" : "rebased";
+  } catch (error) {
+    await git(["rebase", "--abort"]).catch(() => void 0);
+    throw new CornerBranchDivergedError(divergedReason(input.featureBranch, error));
+  }
+}
+async function contains(git, head, ancestor) {
+  return git(["merge-base", "--is-ancestor", ancestor, head]).then(() => true, () => false);
+}
+function divergedReason(featureBranch, error) {
+  const detail = String(error?.stderr ?? "").split("\n").map((line) => line.trim()).find((line) => /conflict|could not|error:/i.test(line));
+  return [
+    `could not rebase onto origin/${featureBranch}: another agent pushed to this corner's branch`,
+    detail ? ` (${detail})` : "",
+    ". Nothing was pushed; the branch needs a person."
+  ].join("").slice(0, 200);
+}
+
 // apps/body/dist/room-session.js
 import { resolve as resolve15 } from "node:path";
 
@@ -16734,7 +16793,7 @@ process.exit(result.status ?? 1);
 }
 
 // apps/body/dist/monolith-corner-turn.js
-var execFileAsync2 = promisify2(execFile3);
+var execFileAsync3 = promisify3(execFile4);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
 var TOOL_OUTPUT_MAX_BYTES = 3200;
 var TOOL_PATH_LIMIT = 12;
@@ -16838,7 +16897,7 @@ async function cornerToolActivity(call, worktreePath, requestedBy) {
   let title = oneLine(redactToolDetail(call.title ?? "")) || `${operation} tool`;
   if (isSuccessfulCommit(call)) {
     try {
-      const shown = await execFileAsync2("git", ["-C", worktreePath, "show", "--format=%s", "--name-only", "--no-renames", "HEAD"], { maxBuffer: 1024 * 1024 });
+      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));
@@ -16894,6 +16953,10 @@ var MonolithCornerTurnLoop = class {
   /** Operator-local turn traces; built once when the daemon configured a directory. */
   turnTraceSink;
   memberNames = /* @__PURE__ */ new Map();
+  /** Agent identities in this Workspace, so a mention can be told from a human's. */
+  agentMembers = /* @__PURE__ */ new Set();
+  /** The member agent that answered in this corner last (`carriesCorner`). */
+  carrier;
   /** The last server check state that started a turn; the same state never starts another. */
   lastChecksState;
   constructor(options) {
@@ -16935,6 +16998,7 @@ var MonolithCornerTurnLoop = class {
       workspaceId: this.options.workspaceId
     });
     this.memberNames = new Map(roster.members.map((member) => [member.identityId, member.name]));
+    this.agentMembers = new Set(roster.members.filter((member) => member.kind === "agent").map((member) => member.identityId));
     return roster;
   }
   /**
@@ -17011,8 +17075,8 @@ var MonolithCornerTurnLoop = class {
       GITHUB_TOKEN: this.options.githubToken
     };
     if (this.options.config.runtimeConfigPath && this.options.config.agentHomeRoot) {
-      const gitBinary = (await execFileAsync2("which", ["git"])).stdout.trim();
-      const ghBinary = await execFileAsync2("which", ["gh"]).then((result) => result.stdout.trim()).catch(() => void 0);
+      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,
@@ -17117,6 +17181,7 @@ var MonolithCornerTurnLoop = class {
         personaInstructions,
         `You are in an isolated git worktree on ${this.options.featureBranch}, targeting ${this.options.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 ${this.options.featureBranch}. Run git pull --rebase origin ${this.options.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.",
@@ -17216,6 +17281,7 @@ var MonolithCornerTurnLoop = class {
       ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
     } : void 0;
     this.currentTurn = { requestId, ...requester ? { requester } : {} };
+    this.carrier = this.agent.publicKey;
     const trace = this.beginTurnTrace(requestId);
     try {
       await withTurnReceiptHeartbeat(api, {
@@ -17232,6 +17298,7 @@ var MonolithCornerTurnLoop = class {
           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 }),
             this.roster(),
@@ -17355,6 +17422,63 @@ ${trigger}`,
       this.currentTurn = void 0;
     }
   }
+  /** Whether this agent opened the corner. A corner with no recorded opener
+   *  behaves exactly as it did before members could carry it. */
+  isOpener() {
+    return !this.options.openedBy || this.options.openedBy === this.agent.publicKey;
+  }
+  /**
+   * Whether this agent is the one carrying the corner right now.
+   *
+   * Every member agent polls the corner, but its lifecycle — a server check
+   * note, a close request answered with work — is ONE fact and must start ONE
+   * turn, not one per member (the "one check turn per changed server state"
+   * rule). The carrier is whoever answered in the corner last, which is the
+   * opener until a human hands the work to someone else.
+   */
+  carriesCorner() {
+    return (this.carrier ?? this.options.openedBy ?? this.agent.publicKey) === this.agent.publicKey;
+  }
+  /** Notes an agent's durable message as the corner changing hands. */
+  noteCarrier(authorId) {
+    if (this.agentMembers.has(authorId))
+      this.carrier = authorId;
+  }
+  /**
+   * 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 token = await this.options.api.execute("getRoomGitHubToken", { roomId: this.options.parentRoomId }).then((granted) => granted.token).catch(() => this.options.githubToken);
+    await syncCornerBranch({
+      worktreePath: this.options.worktreePath,
+      featureBranch: this.options.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 {
@@ -17373,8 +17497,12 @@ ${trigger}`,
     const { api, cornerId, signal } = this.options;
     let cursor3 = (await api.execute("getRoomInbox", { roomId: cornerId, startAtLatest: true })).cursor;
     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) {
+    if (durableAgentReplies.length === 0 && this.isOpener()) {
       await this.prompt(history.items.find((item) => item.requestId)?.requestId ?? cornerId.replaceAll("-", ""), this.options.objective);
     }
     try {
@@ -17392,8 +17520,11 @@ ${trigger}`,
           const checkNotes = [];
           for (const item of inbox.items) {
             if (item.type === "message") {
+              this.noteCarrier(item.authorId);
               if (item.authorId === this.agent.publicKey)
                 continue;
+              if (!await this.addressesThisAgent(item))
+                continue;
               const authority = await api.execute("getRoomAuthority", {
                 roomId: cornerId,
                 principalId: item.authorId
@@ -17418,7 +17549,7 @@ This answers your grant request; resume the paused work. If approved and it is a
             if (completedCheckNote(item))
               checkNotes.push(item);
           }
-          if (checkNotes.length) {
+          if (checkNotes.length && this.carriesCorner()) {
             const state = await this.checksState(checkNotes);
             if (state && state !== "pending" && state !== this.lastChecksState) {
               this.lastChecksState = state;
@@ -17494,7 +17625,13 @@ function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_S
   return isMountedMcpToolPermissionRequest(request, mountedServers);
 }
 function roomPrincipalMayAddressAgent(authority, humanPermitted) {
-  return authority.member && (authority.principalKind === "agent" || authority.principalKind === "human" && humanPermitted);
+  if (!authority.member)
+    return false;
+  if (authority.principalKind === "agent")
+    return true;
+  if (authority.principalKind !== "human")
+    return false;
+  return authority.mayAddressAgent ?? humanPermitted;
 }
 function isScheduledPrompt(item, agentId) {
   if (item.type !== "system" || !item.mentionIds.includes(agentId))
@@ -17541,6 +17678,27 @@ function pendingGrantToolCall(call) {
     return false;
   return /pending, card posted/i.test(typeof call.content === "string" ? call.content : JSON.stringify(call.content ?? ""));
 }
+function roomMentionDirectory(roster, selfId) {
+  const rows = [];
+  for (const member of roster.members) {
+    if (member.identityId === selfId)
+      continue;
+    const handle = member.handle?.trim().replace(/^@/, "");
+    const name = member.name?.trim() ?? "";
+    const alias = handle || name;
+    if (!alias)
+      continue;
+    const kind = member.kind === "agent" ? "agent" : "person";
+    rows.push(`- @${alias}${name && name !== alias ? ` \u2014 ${name}` : ""} (${kind})`);
+  }
+  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 escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -18051,6 +18209,7 @@ var MonolithRoomTurnLoop = class {
               "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),
             [
               "Write only the substantive Room message you want the human to read.",
               "Do not repeat or paraphrase these instructions.",
@@ -18675,8 +18834,77 @@ var ROOM_JOIN_CONCURRENCY = 4;
 var DEFAULT_ROOM_WATCHDOG_STALE_MS = 9e4;
 var DEFAULT_RECONCILE_HEARTBEAT_MS = 6e4;
 var DEFAULT_DRAIN_DEADLINE_MS = 30 * 6e4;
-function shouldPostInitialCornerWorkingState(restore) {
-  return !restore.featureBranch && !restore.lifecycle?.branch && !restore.lifecycle?.pr;
+function shouldPostInitialCornerWorkingState(restore, isOpener = true) {
+  return isOpener && !restore.featureBranch && !restore.lifecycle?.branch && !restore.lifecycle?.pr;
+}
+async function materializeCornerWorktree(input) {
+  const remote = roomCheckoutRemote(input.remote);
+  const repositoryHash = createHash4("sha256").update(remote).digest("hex").slice(0, 24);
+  const gitCommonDir = resolve19(input.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
+  const path = resolve19(input.supervisorRoot, "beeline", "corners", input.cornerId);
+  await mkdir11(dirname6(gitCommonDir), { recursive: true, mode: 448 });
+  await mkdir11(dirname6(path), { recursive: true, mode: 448 });
+  const authEnv = githubGitEnv(input.token);
+  if (!existsSync4(resolve19(gitCommonDir, "HEAD"))) {
+    await execFileAsync4("git", ["clone", "--bare", remote, gitCommonDir], {
+      env: authEnv,
+      maxBuffer: 4 * 1024 * 1024
+    });
+  }
+  await execFileAsync4("git", [
+    `--git-dir=${gitCommonDir}`,
+    "fetch",
+    "--prune",
+    "origin",
+    `+refs/heads/${input.targetBranch}:refs/remotes/origin/${input.targetBranch}`
+  ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
+  const restored = await execFileAsync4("git", [
+    `--git-dir=${gitCommonDir}`,
+    "fetch",
+    "origin",
+    `+refs/heads/${input.featureBranch}:refs/remotes/origin/${input.featureBranch}`
+  ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 }).then(() => true, () => false);
+  if (!existsSync4(resolve19(path, ".git"))) {
+    await rm4(path, { recursive: true, force: true });
+    await execFileAsync4("git", [
+      `--git-dir=${gitCommonDir}`,
+      "worktree",
+      "add",
+      "-B",
+      input.featureBranch,
+      path,
+      restored ? `refs/remotes/origin/${input.featureBranch}` : `refs/remotes/origin/${input.targetBranch}`
+    ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
+  }
+  await execFileAsync4("git", [
+    `--git-dir=${gitCommonDir}`,
+    "config",
+    "extensions.worktreeConfig",
+    "true"
+  ]);
+  await execFileAsync4("git", ["-C", path, "config", "--worktree", "core.bare", "false"]);
+  await execFileAsync4("git", [
+    "-C",
+    path,
+    "config",
+    "--worktree",
+    "credential.https://github.com.helper",
+    "!f() { echo username=x-access-token; echo password=$GH_TOKEN; }; f"
+  ]);
+  await execFileAsync4("git", ["-C", path, "config", "--worktree", "user.name", input.committer.name]);
+  await execFileAsync4("git", [
+    "-C",
+    path,
+    "config",
+    "--worktree",
+    "user.email",
+    `${input.committer.publicKey.slice(0, 16)}@users.noreply.github.com`
+  ]);
+  const top = await execFileAsync4("git", ["-C", path, "rev-parse", "--show-toplevel"]);
+  if (resolve19(top.stdout.trim()) !== resolve19(path)) {
+    throw new Error(`corner worktree escaped its isolated root: ${top.stdout.trim()}`);
+  }
+  return { path, gitCommonDir };
 }
 function reconcileRetryMs(error, pollMs) {
   const match = String(error).match(/retry in\s+(\d+)s/i);
@@ -18691,7 +18919,7 @@ async function mapWithConcurrency(values, limit, visit) {
     }
   }));
 }
-var execFileAsync3 = promisify3(execFile4);
+var execFileAsync4 = promisify4(execFile5);
 var RoomRuntimeCoordinator = class {
   configPath;
   baseConfig;
@@ -18699,6 +18927,8 @@ var RoomRuntimeCoordinator = class {
   runtime;
   running = /* @__PURE__ */ new Map();
   startingCorners = /* @__PURE__ */ new Set();
+  /** Corners whose start failure has already been said out loud, once each. */
+  reportedCornerStartFailures = /* @__PURE__ */ new Set();
   scheduler;
   agent;
   /** Parent ownership retained so a failed corner listing never authorizes removal. */
@@ -18824,7 +19054,8 @@ var RoomRuntimeCoordinator = class {
             desired.add(corner.cornerId);
             desiredCorners.set(corner.cornerId, {
               cornerId: corner.cornerId,
-              parentRoomId: room.roomId
+              parentRoomId: room.roomId,
+              ...corner.createdBy ? { openedBy: corner.createdBy } : {}
             });
           }
         }
@@ -18966,12 +19197,12 @@ var RoomRuntimeCoordinator = class {
     const token = remote.startsWith("https://github.com/") ? await this.options.daemonApi.execute("getRoomGitHubToken", { roomId }) : void 0;
     const env = token ? githubGitEnv(token.token) : process.env;
     if (!existsSync4(resolve19(path, ".git"))) {
-      await execFileAsync3("git", ["clone", "--no-checkout", remote, path], {
+      await execFileAsync4("git", ["clone", "--no-checkout", remote, path], {
         env,
         maxBuffer: 4 * 1024 * 1024
       });
     }
-    await execFileAsync3("git", [
+    await execFileAsync4("git", [
       "-C",
       path,
       "fetch",
@@ -18979,7 +19210,7 @@ var RoomRuntimeCoordinator = class {
       "origin",
       `+refs/heads/${targetBranch}:refs/remotes/origin/${targetBranch}`
     ], { env, maxBuffer: 4 * 1024 * 1024 });
-    await execFileAsync3("git", ["-C", path, "checkout", "--detach", "--force", `origin/${targetBranch}`], {
+    await execFileAsync4("git", ["-C", path, "checkout", "--detach", "--force", `origin/${targetBranch}`], {
       env,
       maxBuffer: 4 * 1024 * 1024
     });
@@ -19022,7 +19253,8 @@ var RoomRuntimeCoordinator = class {
         featureBranch,
         token: granted.token
       });
-      if (shouldPostInitialCornerWorkingState(restore)) {
+      const isOpener = !corner.openedBy || corner.openedBy === this.agent.publicKey;
+      if (shouldPostInitialCornerWorkingState(restore, isOpener)) {
         await this.options.daemonApi.execute("postCornerRemoteState", {
           cornerId: corner.cornerId,
           branch: featureBranch,
@@ -19039,6 +19271,7 @@ var RoomRuntimeCoordinator = class {
         ...grantRunnerEndpoint ? { grantRunnerEndpoint } : {},
         parentRoomId: corner.parentRoomId,
         workspaceId: this.runtime.communityId,
+        ...corner.openedBy ? { openedBy: corner.openedBy } : {},
         objective,
         featureBranch,
         targetBranch,
@@ -19080,79 +19313,60 @@ var RoomRuntimeCoordinator = class {
           branch: featureBranch
         }
       });
+      this.reportedCornerStartFailures.delete(corner.cornerId);
       console.log(`[thin-core] serving corner ${corner.cornerId} on ${featureBranch} at ${worktree.path}`);
     } catch (error) {
       console.error(`[thin-core] failed to start corner ${corner.cornerId}:`, error);
+      await this.reportCornerStartFailure(corner.cornerId, error);
     } finally {
       this.startingCorners.delete(corner.cornerId);
     }
   }
-  async materializeCornerWorktree(input) {
-    const remote = githubHttpsRemote(input.remote);
-    const repositoryHash = createHash4("sha256").update(remote).digest("hex").slice(0, 24);
-    const gitCommonDir = resolve19(this.runtime.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
-    const path = resolve19(this.runtime.supervisorRoot, "beeline", "corners", input.cornerId);
-    await mkdir11(dirname6(gitCommonDir), { recursive: true, mode: 448 });
-    await mkdir11(dirname6(path), { recursive: true, mode: 448 });
-    const authEnv = githubGitEnv(input.token);
-    if (!existsSync4(resolve19(gitCommonDir, "HEAD"))) {
-      await execFileAsync3("git", ["clone", "--bare", remote, gitCommonDir], {
-        env: authEnv,
-        maxBuffer: 4 * 1024 * 1024
+  /**
+   * An agent addressed in a corner it then could not restore must not be
+   * silent about it.
+   *
+   * The corner never starts, so no turn ever runs and nothing else in the
+   * daemon has a Room to say it in. This posts a FAILED receipt against the
+   * message that asked, which the server inscribes as `<agent> could not
+   * answer · <reason>` in the corner itself. Once per corner per process: the
+   * reconciliation heartbeat retries the start for as long as it keeps
+   * failing, and the fact is worth saying once, not once a minute.
+   */
+  async reportCornerStartFailure(cornerId, error) {
+    if (this.reportedCornerStartFailures.has(cornerId))
+      return;
+    this.reportedCornerStartFailures.add(cornerId);
+    try {
+      const conversation = await this.options.daemonApi.execute("getRoomConversation", {
+        roomId: cornerId,
+        limit: 50
       });
+      const asked = [...conversation.items].reverse().find((item) => item.type === "message" && item.mentionIds.includes(this.agent.publicKey));
+      if (!asked)
+        return;
+      await this.options.daemonApi.execute("postAgentTurnReceipt", {
+        agentId: this.agent.publicKey,
+        roomId: cornerId,
+        requestId: asked.id,
+        status: "failed",
+        generationId: `${this.agent.publicKey}:${cornerId}`,
+        reason: distillTurnFailureReason(error)
+      });
+    } catch (reportError) {
+      console.error(`[thin-core] corner ${cornerId} start-failure report failed:`, reportError);
     }
-    await execFileAsync3("git", [
-      `--git-dir=${gitCommonDir}`,
-      "fetch",
-      "--prune",
-      "origin",
-      `+refs/heads/${input.targetBranch}:refs/remotes/origin/${input.targetBranch}`
-    ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
-    if (!existsSync4(resolve19(path, ".git"))) {
-      await rm4(path, { recursive: true, force: true });
-      await execFileAsync3("git", [
-        `--git-dir=${gitCommonDir}`,
-        "worktree",
-        "add",
-        "-B",
-        input.featureBranch,
-        path,
-        `refs/remotes/origin/${input.targetBranch}`
-      ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
-    }
-    await execFileAsync3("git", [
-      `--git-dir=${gitCommonDir}`,
-      "config",
-      "extensions.worktreeConfig",
-      "true"
-    ]);
-    await execFileAsync3("git", ["-C", path, "config", "--worktree", "core.bare", "false"]);
-    await execFileAsync3("git", [
-      "-C",
-      path,
-      "config",
-      "--worktree",
-      "credential.https://github.com.helper",
-      "!f() { echo username=x-access-token; echo password=$GH_TOKEN; }; f"
-    ]);
-    await execFileAsync3("git", ["-C", path, "config", "--worktree", "user.name", this.agent.name]);
-    await execFileAsync3("git", [
-      "-C",
-      path,
-      "config",
-      "--worktree",
-      "user.email",
-      `${this.agent.publicKey.slice(0, 16)}@users.noreply.github.com`
-    ]);
-    const top = await execFileAsync3("git", ["-C", path, "rev-parse", "--show-toplevel"]);
-    if (resolve19(top.stdout.trim()) !== resolve19(path)) {
-      throw new Error(`corner worktree escaped its isolated root: ${top.stdout.trim()}`);
-    }
-    return { path, gitCommonDir };
+  }
+  async materializeCornerWorktree(input) {
+    return materializeCornerWorktree({
+      ...input,
+      supervisorRoot: this.runtime.supervisorRoot,
+      committer: { name: this.agent.name, publicKey: this.agent.publicKey }
+    });
   }
   async reapCornerWorktree(worktree) {
     if (existsSync4(worktree.path)) {
-      await execFileAsync3("git", [
+      await execFileAsync4("git", [
         `--git-dir=${worktree.gitCommonDir}`,
         "worktree",
         "remove",
@@ -19322,13 +19536,13 @@ var ThinDaemonCore = class {
 };
 
 // apps/body/dist/systemd.js
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { mkdir as mkdir12, readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname7, resolve as resolve20 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
-import { promisify as promisify4 } from "node:util";
-var execFileAsync4 = promisify4(execFile5);
+import { promisify as promisify5 } from "node:util";
+var execFileAsync5 = promisify5(execFile6);
 var DELIBERATE_REMOVAL_EXIT_STATUS = 78;
 var DAEMON_DISTRESS_EXIT_STATUS = 77;
 var UNKNOWN_AGENT_EXIT_STATUS = 79;
@@ -19381,7 +19595,7 @@ function systemdUserUnitPath(env = process.env) {
   return resolve20(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 var runSystemctl = async (args) => {
-  const result = await execFileAsync4("systemctl", ["--user", ...args], {
+  const result = await execFileAsync5("systemctl", ["--user", ...args], {
     timeout: SYSTEMD_COMMAND_TIMEOUT_MS,
     encoding: "utf8"
   });
@@ -19447,7 +19661,7 @@ async function disableAgentService(publicKey, options = {}) {
 async function notify(fields) {
   if (process.env.BEELINE_MANAGED_BY_SYSTEMD !== "1")
     return;
-  await execFileAsync4("systemd-notify", fields, { timeout: SYSTEMD_COMMAND_TIMEOUT_MS });
+  await execFileAsync5("systemd-notify", fields, { timeout: SYSTEMD_COMMAND_TIMEOUT_MS });
 }
 async function extendSystemdStartTimeout(ms) {
   await notify([`EXTEND_TIMEOUT_USEC=${Math.max(0, Math.round(ms)) * 1e3}`]).catch(() => void 0);
@@ -20408,8 +20622,10 @@ import { mkdir as mkdir16, rm as rm6, stat as stat2, writeFile as writeFile12 }
 import { dirname as dirname12, resolve as resolve24 } from "node:path";
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir15, readFile as readFile11, rename as rename4, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir15, readFile as readFile11, rename as rename4, unlink as unlink3, writeFile as writeFile11 } from "node:fs/promises";
 import { dirname as dirname11, resolve as resolve23 } from "node:path";
+var REPORT_INTERVAL_MS = 60 * 60 * 1e3;
+var lastLogged = /* @__PURE__ */ new Map();
 function updateRollbackAlertPath(runtimeDir) {
   return resolve23(runtimeDir, "update-rollback-alert.json");
 }
@@ -20437,11 +20653,37 @@ async function readUpdateRollbackAlert(runtimeDir) {
     return void 0;
   }
 }
+async function clearUpdateRollbackAlert(runtimeDir) {
+  const existing = await readUpdateRollbackAlert(runtimeDir);
+  if (!existing)
+    return false;
+  await unlink3(updateRollbackAlertPath(runtimeDir)).catch(() => void 0);
+  lastLogged.delete(runtimeDir);
+  return true;
+}
+async function clearUpdateRollbackAlertIfConfirmed(runtimeDir, loadedRelease) {
+  if (!loadedRelease)
+    return false;
+  const existing = await readUpdateRollbackAlert(runtimeDir);
+  if (!existing || existing.releaseId !== loadedRelease)
+    return false;
+  await unlink3(updateRollbackAlertPath(runtimeDir)).catch(() => void 0);
+  lastLogged.delete(runtimeDir);
+  return true;
+}
 async function reportUpdateRollback(input) {
   const pending = await readUpdateRollbackAlert(input.runtimeDir);
-  if (!pending)
+  if (!pending) {
+    lastLogged.delete(input.runtimeDir);
     return false;
+  }
+  const now2 = input.now ?? Date.now();
+  const last = lastLogged.get(input.runtimeDir);
+  if (last && last.releaseId === pending.releaseId && now2 - last.loggedAt < REPORT_INTERVAL_MS) {
+    return false;
+  }
   console.error(`[thin-core] UPDATE ROLLBACK: ${pending.releaseId}; durable operator record: ` + updateRollbackAlertPath(input.runtimeDir));
+  lastLogged.set(input.runtimeDir, { releaseId: pending.releaseId, loggedAt: now2 });
   return true;
 }
 
@@ -21146,6 +21388,7 @@ import { resolve as resolve26 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
 var UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS = 2e4;
 var UPDATE_PROBE_TURN_TIMEOUT_MS = 45e3;
+var UPDATE_PROBE_RETRY_DELAY_MS = 2e3;
 var ACP_ERROR_CODE = /\bACP error (-\d+):/;
 var ACP_PROMPT_INACTIVITY = /\bACP session\/prompt timed out after \d+ms of inactivity\b/;
 function isServerInternalCode(code) {
@@ -21269,8 +21512,7 @@ async function runUpdateFunctionalProbe(input) {
     });
     const sessionTimeoutMs = input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_TIMEOUT_MS;
     const sessionOpenTimeoutMs = input.sessionOpenTimeoutMs ?? input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS;
-    try {
-      await client.start(sessionTimeoutMs);
+    const openSessionAndPrompt = async () => {
       const opened = await client.sessionNew({
         cwd,
         mcpServers: [],
@@ -21281,15 +21523,22 @@ async function runUpdateFunctionalProbe(input) {
       if (input.config.modelSelection) {
         await applyAgentModelSelection(client, opened.sessionId, parseAdvertisedConfigOptions(opened.raw, input.config.modelSelection.model, isGrokAgentCommand(selectedAgent)), input.config.modelSelection);
       }
+      return {
+        sessionId: opened.sessionId,
+        served: await client.sessionPrompt(opened.sessionId, "Reply READY.", input.turnTimeoutMs ?? UPDATE_PROBE_TURN_TIMEOUT_MS)
+      };
+    };
+    try {
+      await client.start(sessionTimeoutMs);
       try {
-        const served = await client.sessionPrompt(opened.sessionId, "Reply READY.", input.turnTimeoutMs ?? UPDATE_PROBE_TURN_TIMEOUT_MS);
+        const { sessionId, served } = await openSessionAndPrompt();
         if (served.agentText.trim()) {
           modelAnswer = { modelAnswer: "served" };
         } else {
           const explained = await explainEmptyAgentTurn({
             agentLabel: command,
             agentEnv,
-            sessionId: opened.sessionId,
+            sessionId,
             result: served
           });
           const modelSide = isAccountOrProviderRefusal(explained.record) || explained.record?.kind === "empty";
@@ -21317,29 +21566,55 @@ async function runUpdateFunctionalProbe(input) {
             modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: explained.reason };
           }
         }
-      } catch (error) {
-        if (error instanceof UpdateFunctionalProbeError)
-          throw error;
-        const detail = error instanceof Error ? error.message : String(error);
-        const failure = classifyAcpTurnFailure(error);
-        if (!failure || !input.compareWithCurrentRelease) {
-          throw new UpdateFunctionalProbeError("turn-failed", detail, { cause: error });
+      } catch (initialError) {
+        if (initialError instanceof UpdateFunctionalProbeError)
+          throw initialError;
+        let error = initialError;
+        let detail = error instanceof Error ? error.message : String(error);
+        let failure = classifyAcpTurnFailure(error);
+        if (failure) {
+          await new Promise((resolveWait) => setTimeout(resolveWait, input.retryDelayMs ?? UPDATE_PROBE_RETRY_DELAY_MS));
+          try {
+            const retried = await openSessionAndPrompt();
+            if (retried.served.agentText.trim()) {
+              turnCompleted = true;
+              modelAnswer = { modelAnswer: "served" };
+              console.warn(`[body] update probe: the probe turn failed once (${detail}) but a fresh retry answered; treating the first failure as the provider's, not this bundle's`);
+              error = void 0;
+            }
+          } catch (retryError) {
+            const retryDetail = retryError instanceof Error ? retryError.message : String(retryError);
+            const retryFailure = classifyAcpTurnFailure(retryError);
+            if (!retryFailure || !sameAcpTurnFailure(failure, retryFailure)) {
+              throw new UpdateFunctionalProbeError("turn-failed", retryDetail, {
+                cause: retryError
+              });
+            }
+            error = retryError;
+            detail = retryDetail;
+            failure = retryFailure;
+          }
         }
-        const current = await input.compareWithCurrentRelease({
-          kind: "acp-turn-failure",
-          reason: detail,
-          failure
-        });
-        const currentFailure = current.kind === "unavailable" ? classifyAcpTurnFailure(current.reason) : void 0;
-        if (!currentFailure || !sameAcpTurnFailure(failure, currentFailure)) {
-          throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { cause: error });
+        if (error === void 0) {
+        } else if (!failure || !input.compareWithCurrentRelease) {
+          throw new UpdateFunctionalProbeError("turn-failed", detail, { cause: error });
+        } else {
+          const current = await input.compareWithCurrentRelease({
+            kind: "acp-turn-failure",
+            reason: detail,
+            failure
+          });
+          const currentFailure = current.kind === "unavailable" ? classifyAcpTurnFailure(current.reason) : void 0;
+          if (!currentFailure || !sameAcpTurnFailure(failure, currentFailure)) {
+            throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { cause: error });
+          }
+          console.warn(`[body] update probe: the probe turn failed the same way on this release and the current release (${detail}); that failure is not this bundle's doing, so the probe passes as inconclusive`);
+          turnCompleted = false;
+          modelAnswer = {
+            modelAnswer: "unavailable",
+            modelAnswerReason: `${detail} (the current release fails the same way)`
+          };
         }
-        console.warn(`[body] update probe: the probe turn failed the same way on this release and the current release (${detail}); that failure is not this bundle's doing, so the probe passes as inconclusive`);
-        turnCompleted = false;
-        modelAnswer = {
-          modelAnswer: "unavailable",
-          modelAnswerReason: `${detail} (the current release fails the same way)`
-        };
       }
     } catch (error) {
       if (error instanceof UpdateFunctionalProbeError)
@@ -21403,7 +21678,7 @@ async function probeReleaseInSubprocess(input) {
     return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
   }
   const timeoutMs = input.timeoutMs ?? CURRENT_RELEASE_PROBE_TIMEOUT_MS;
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     const child = spawn7(input.execPath ?? process.execPath, [entrypoint, UPDATE_PROBE_COMMAND, "--config", input.runtimeConfigPath], { env: input.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout6 = "";
     let stderr = "";
@@ -21413,7 +21688,7 @@ async function probeReleaseInSubprocess(input) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve29(outcome);
+      resolve30(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -21518,6 +21793,90 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
   return status;
 }
 
+// apps/body/dist/scratch-sweep.js
+import { lstat as lstat3, readdir as readdir6, rmdir, unlink as unlink4 } from "node:fs/promises";
+import { resolve as resolve28 } from "node:path";
+var DEFAULT_SCRATCH_TTL_HOURS = 72;
+var NEVER_SWEEP_SUBDIR_NAMES = new Set(HOME_SUBDIRS.filter((name) => name !== "tmp"));
+function scratchTtlMs(env = process.env) {
+  const raw = env.BEELINE_SCRATCH_TTL_HOURS?.trim();
+  const hours = raw ? Number(raw) : DEFAULT_SCRATCH_TTL_HOURS;
+  return (Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_SCRATCH_TTL_HOURS) * 60 * 60 * 1e3;
+}
+async function discoverAttachScratchRoots(runtimeDir) {
+  const roomsDir = resolve28(runtimeDir, "rooms");
+  let entries;
+  try {
+    entries = await readdir6(roomsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const roots = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const home = resolve28(roomsDir, entry.name, "agent-home");
+    const stats = await lstat3(home).catch(() => void 0);
+    if (stats?.isDirectory())
+      roots.push(home);
+  }
+  return roots;
+}
+async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
+  let entries;
+  try {
+    entries = await readdir6(dir, { withFileTypes: true });
+  } catch {
+    return { removedFiles: 0, removedBytes: 0 };
+  }
+  let removedFiles = 0;
+  let removedBytes = 0;
+  for (const entry of entries) {
+    if (protectNamesHere && NEVER_SWEEP_SUBDIR_NAMES.has(entry.name))
+      continue;
+    const path = resolve28(dir, entry.name);
+    const stats = await lstat3(path).catch(() => void 0);
+    if (!stats || stats.isSymbolicLink())
+      continue;
+    if (stats.isDirectory()) {
+      const nested = await removeStaleFiles(path, cutoffMs, false);
+      removedFiles += nested.removedFiles;
+      removedBytes += nested.removedBytes;
+      const remaining = await readdir6(path).catch(() => void 0);
+      if (remaining && remaining.length === 0)
+        await rmdir(path).catch(() => void 0);
+      continue;
+    }
+    if (!stats.isFile() || stats.mtimeMs >= cutoffMs)
+      continue;
+    await unlink4(path).catch(() => void 0);
+    removedFiles += 1;
+    removedBytes += stats.size;
+  }
+  return { removedFiles, removedBytes };
+}
+async function sweepAttachScratchRoots(roots, ttlMs, now2 = Date.now()) {
+  const cutoffMs = now2 - ttlMs;
+  let removedFiles = 0;
+  let removedBytes = 0;
+  for (const root of roots) {
+    const stats = await lstat3(root).catch(() => void 0);
+    if (!stats?.isDirectory())
+      continue;
+    const result = await removeStaleFiles(root, cutoffMs, true);
+    removedFiles += result.removedFiles;
+    removedBytes += result.removedBytes;
+  }
+  return { removedFiles, removedBytes, roots: roots.length };
+}
+async function runScratchSweep(runtimeDir, env = process.env) {
+  const roots = await discoverAttachScratchRoots(runtimeDir);
+  const ttlMs = scratchTtlMs(env);
+  const summary = await sweepAttachScratchRoots(roots, ttlMs);
+  console.log(`[body] scratch sweep: removed ${summary.removedFiles} files (${summary.removedBytes} bytes) older than ${Math.round(ttlMs / (60 * 60 * 1e3))}h under ${summary.roots} roots`);
+  return summary;
+}
+
 // apps/body/dist/cli.js
 function usage(exitCode = 1) {
   console.error(`
@@ -21548,6 +21907,10 @@ All other config via env vars (see config.ts).
   process.exit(exitCode);
 }
 var daemonFailureRuntimeDir;
+var SCRATCH_SWEEP_INTERVAL_MS = 6 * 60 * 6e4;
+function runScratchSweepLogged(runtimeDir) {
+  void runScratchSweep(runtimeDir).catch((error) => console.error("[body] scratch sweep failed:", error));
+}
 var DaemonExitError = class extends Error {
   exitStatus;
   constructor(message, exitStatus) {
@@ -21570,7 +21933,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile15(resolve28(dirname15(configPath), "daemon.pid"), `${process.pid}
+  await writeFile15(resolve29(dirname15(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -21578,7 +21941,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve28(dirname15(configPath), "workspace"),
+    workspaceRoot: resolve29(dirname15(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -21645,6 +22008,7 @@ async function runStoredDaemon(pathOrPointer) {
       pendingSuccessor = true;
     }
     loadedRelease = await activeReleaseId(layout);
+    await clearUpdateRollbackAlertIfConfirmed(runtimeDir, loadedRelease);
     loadedReleaseIdentity = await readInstalledBundleIdentity(layout);
     config.daemonReleaseVersion = loadedReleaseIdentity?.version;
     config.daemonSourceSha = loadedReleaseIdentity?.commit;
@@ -21655,6 +22019,9 @@ async function runStoredDaemon(pathOrPointer) {
   console.log(`[beeline] thin daemon core ${runtime.communityId} starting with ${runtime.rooms.length} Room binding(s)`);
   console.log(`[body] agent binary: ${formatAgentCommand(agent)}`);
   console.log(`[body] ${sandbox.advisory}`);
+  runScratchSweepLogged(runtimeDir);
+  const scratchSweepTimer = setInterval(() => runScratchSweepLogged(runtimeDir), SCRATCH_SWEEP_INTERVAL_MS);
+  scratchSweepTimer.unref();
   let ready = false;
   let stoppingStatus = "daemon stopped";
   try {
@@ -21710,6 +22077,7 @@ async function runStoredDaemon(pathOrPointer) {
           }
           functionalProof = gate.proof;
           pendingSuccessor = false;
+          await clearUpdateRollbackAlert(runtimeDir);
           console.log(`[thin-core] successor functional probe passed on exact release ${loadedRelease}: ${functionalProof?.harness ?? "unknown"} session/new + turn` + (functionalProof?.modelAnswer === "unavailable" ? ` (model answer unavailable: ${functionalProof.modelAnswerReason})` : ""));
         }
         await clearDaemonStartFailures(runtimeDir);
@@ -21752,11 +22120,12 @@ async function runStoredDaemon(pathOrPointer) {
     }
     throw error;
   } finally {
+    clearInterval(scratchSweepTimer);
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve28(dirname15(configPath), "daemon.pid");
+    const pidPath = resolve29(dirname15(configPath), "daemon.pid");
     const recorded = Number((await readFile14(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
-      await unlink3(pidPath).catch(() => void 0);
+      await unlink5(pidPath).catch(() => void 0);
     }
   }
 }
@@ -21781,7 +22150,7 @@ async function main() {
     const roomId = roomFlag >= 0 ? args[roomFlag + 1] : void 0;
     if (!configPath || !roomId)
       throw new Error("corner-read-token requires --config and --room");
-    const activated = await activateDaemonTransport(resolve28(configPath));
+    const activated = await activateDaemonTransport(resolve29(configPath));
     if (!activated)
       throw new Error("corner-read-token requires monolith transport");
     const credential = await activated.client.execute("getRoomGitHubToken", { roomId });
@@ -21843,7 +22212,7 @@ async function main() {
     }
     if (!configPath)
       throw new Error("daemon requires --config <runtime.json> or --agent <pubkey>");
-    await runStoredDaemon(resolve28(configPath));
+    await runStoredDaemon(resolve29(configPath));
     return;
   }
   if (command === "update") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.0.53",
+  "version": "0.0.56",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {