usebeeline 0.0.54 → 0.0.57

package/dist/usebeeline.mjs

@@ -291,6 +291,7 @@ __export(self_update_exports, {
   beelineInstallLayout: () => beelineInstallLayout,
   defaultBeelineInstallLayout: () => defaultBeelineInstallLayout,
   describeIdentity: () => describeIdentity,
+  discoveredBeelineInstallLayout: () => discoveredBeelineInstallLayout,
   hostPlatformKey: () => hostPlatformKey,
   normalizeLegacyBundleShape: () => normalizeLegacyBundleShape,
   readInstalledBundleIdentity: () => readInstalledBundleIdentity,
@@ -345,6 +346,15 @@ function defaultBeelineInstallLayout(env = process.env) {
   const home = env.HOME?.trim() || homedir9();
   return anchorLayout(resolve21(home, ".local", "lib", "beeline"));
 }
+function discoveredBeelineInstallLayout(env = process.env) {
+  const explicitAnchor = env.BEELINE_INSTALL_LIB_DIR?.trim();
+  if (explicitAnchor)
+    return anchorLayout(explicitAnchor);
+  const explicitBinDir = env.BEELINE_INSTALL_DIR?.trim();
+  if (explicitBinDir)
+    return anchorLayout(resolve21(dirname9(resolve21(explicitBinDir)), "lib", "beeline"));
+  return defaultBeelineInstallLayout(env);
+}
 function hostPlatformKey() {
   const os = process.platform === "linux" ? "linux" : process.platform === "darwin" ? "darwin" : "";
   const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : "";
@@ -639,27 +649,38 @@ async function normalizeLegacyBundleShape(bundleDir) {
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
-  for (const tool of FORWARDER_TOOLS) {
+  const entries = [
+    ...FORWARDER_TOOLS.map((tool) => [tool, tool]),
+    ...Object.entries(FORWARDER_ALIASES).map(([alias, tool]) => [alias, tool])
+  ];
+  for (const [name, tool] of entries) {
     const target = join7(activeBundleRoot, "bin", tool);
     try {
       await access(target, fsConstants.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join7(layout.binDir, tool), forwarderScript(tool), 493);
+    await replaceFile(join7(layout.binDir, name), forwarderScript(tool), 493);
   }
 }
 async function repairInstallForwarders(layout, opts = {}) {
   if (await pathKind(layout.libDir) !== "symlink")
     return false;
-  const forwarderPath = join7(layout.binDir, "beeline");
-  let current;
-  try {
-    current = await readFile9(forwarderPath, "utf8");
-  } catch {
-    current = void 0;
+  const forwarderHealthy = async (name, tool) => {
+    let current;
+    try {
+      current = await readFile9(join7(layout.binDir, name), "utf8");
+    } catch {
+      current = void 0;
+    }
+    return current === forwarderScript(tool);
+  };
+  let healthy = await forwarderHealthy("beeline", "beeline");
+  for (const [alias, tool] of Object.entries(FORWARDER_ALIASES)) {
+    if (!await forwarderHealthy(alias, tool))
+      healthy = false;
   }
-  if (current === forwarderScript("beeline"))
+  if (healthy)
     return false;
   await mkdir13(layout.binDir, { recursive: true });
   await writeBinForwarders(layout, layout.libDir);
@@ -741,7 +762,7 @@ function describeIdentity(identity) {
     parts.push(identity.commit.slice(0, 12));
   return parts.join(" ") || "unknown";
 }
-var RELEASES_SEGMENT, BUNDLE_ENTRYPOINT, PI_MCP_ADAPTER_ENTRYPOINT, FORWARDER_TOOLS, LEGACY_FLAT_BUNDLE_FILES, DEFAULT_UPDATE_CONFIRM_WINDOW_MS, SelfUpdateManager;
+var RELEASES_SEGMENT, BUNDLE_ENTRYPOINT, PI_MCP_ADAPTER_ENTRYPOINT, FORWARDER_TOOLS, FORWARDER_ALIASES, LEGACY_FLAT_BUNDLE_FILES, DEFAULT_UPDATE_CONFIRM_WINDOW_MS, SelfUpdateManager;
 var init_self_update = __esm({
   "apps/body/dist/self-update.js"() {
     "use strict";
@@ -750,6 +771,9 @@ var init_self_update = __esm({
     BUNDLE_ENTRYPOINT = "lib/beeline/beeline-cli.mjs";
     PI_MCP_ADAPTER_ENTRYPOINT = "lib/beeline/pi-mcp-adapter.mjs";
     FORWARDER_TOOLS = ["beeline", "buzz-agent", "buzz-dev-mcp", "beeline-readonly-mcp"];
+    FORWARDER_ALIASES = {
+      usebeeline: "beeline"
+    };
     LEGACY_FLAT_BUNDLE_FILES = [
       "beeline-cli.mjs",
       "beeline-readonly-mcp.mjs",
@@ -956,7 +980,7 @@ var init_self_update = __esm({
 
 // apps/body/dist/cli.js
 import { dirname as dirname15, resolve as resolve29 } from "node:path";
-import { readFile as readFile14, unlink as unlink4, writeFile as writeFile15 } from "node:fs/promises";
+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 +2975,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)
@@ -13280,12 +13308,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 +14153,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 +14205,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.",
@@ -15931,6 +15959,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";
 
@@ -16740,7 +16817,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;
@@ -16844,7 +16921,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));
@@ -16900,6 +16977,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) {
@@ -16941,6 +17022,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;
   }
   /**
@@ -17017,8 +17099,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,
@@ -17123,6 +17205,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.",
@@ -17222,6 +17305,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, {
@@ -17238,6 +17322,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(),
@@ -17361,6 +17446,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 {
@@ -17379,8 +17521,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 {
@@ -17398,8 +17544,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
@@ -17424,7 +17573,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;
@@ -17500,7 +17649,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))
@@ -17547,6 +17702,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, "\\$&");
 }
@@ -18057,6 +18233,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.",
@@ -18681,8 +18858,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);
@@ -18697,7 +18943,7 @@ async function mapWithConcurrency(values, limit, visit) {
     }
   }));
 }
-var execFileAsync3 = promisify3(execFile4);
+var execFileAsync4 = promisify4(execFile5);
 var RoomRuntimeCoordinator = class {
   configPath;
   baseConfig;
@@ -18705,6 +18951,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. */
@@ -18830,7 +19078,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 } : {}
             });
           }
         }
@@ -18972,12 +19221,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",
@@ -18985,7 +19234,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
     });
@@ -19028,7 +19277,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,
@@ -19045,6 +19295,7 @@ var RoomRuntimeCoordinator = class {
         ...grantRunnerEndpoint ? { grantRunnerEndpoint } : {},
         parentRoomId: corner.parentRoomId,
         workspaceId: this.runtime.communityId,
+        ...corner.openedBy ? { openedBy: corner.openedBy } : {},
         objective,
         featureBranch,
         targetBranch,
@@ -19086,79 +19337,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",
@@ -19328,13 +19560,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;
@@ -19387,7 +19619,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"
   });
@@ -19453,7 +19685,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);
@@ -20414,8 +20646,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");
 }
@@ -20443,11 +20677,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;
 }
 
@@ -20972,12 +21232,14 @@ default 30s) with the same busy gate; BEELINE_UPDATE_DISABLE=1 turns the
 automatic path off. \`beeline update\` always works.
 `);
 }
-function requireLayout() {
+async function requireLayout() {
   const layout = beelineInstallLayout(process.env);
-  if (!layout) {
-    throw new Error("beeline update needs a bundle install (the installer layout). This command was started outside the bundled `beeline` wrapper; update a dev checkout with git instead.");
-  }
-  return layout;
+  if (layout)
+    return layout;
+  const discovered = discoveredBeelineInstallLayout(process.env);
+  if (await readInstalledBundleIdentity(discovered) !== void 0)
+    return discovered;
+  throw new Error("this host has no Beeline install; run `npx usebeeline connect` first.");
 }
 async function runningDaemonConfigPaths() {
   const cwd = process.cwd();
@@ -21025,7 +21287,7 @@ async function runUpdateCommand(args) {
     updateUsage();
     return;
   }
-  const layout = requireLayout();
+  const layout = await requireLayout();
   const manifestUrlFlag = args.indexOf("--manifest-url");
   const manifestUrl = manifestUrlFlag >= 0 && args[manifestUrlFlag + 1] ? args[manifestUrlFlag + 1] : resolveManifestUrl(process.env);
   const checkOnly = args.includes("--check");
@@ -21152,6 +21414,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) {
@@ -21275,8 +21538,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: [],
@@ -21287,15 +21549,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";
@@ -21323,29 +21592,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)
@@ -21525,7 +21820,7 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
 }
 
 // apps/body/dist/scratch-sweep.js
-import { lstat as lstat3, readdir as readdir6, rmdir, unlink as unlink3 } from "node:fs/promises";
+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"));
@@ -21580,7 +21875,7 @@ async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
     }
     if (!stats.isFile() || stats.mtimeMs >= cutoffMs)
       continue;
-    await unlink3(path).catch(() => void 0);
+    await unlink4(path).catch(() => void 0);
     removedFiles += 1;
     removedBytes += stats.size;
   }
@@ -21739,6 +22034,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;
@@ -21807,6 +22103,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);
@@ -21854,7 +22151,7 @@ async function runStoredDaemon(pathOrPointer) {
     const pidPath = resolve29(dirname15(configPath), "daemon.pid");
     const recorded = Number((await readFile14(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
-      await unlink4(pidPath).catch(() => void 0);
+      await unlink5(pidPath).catch(() => void 0);
     }
   }
 }

package/package.json

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