usebeeline 0.0.128 → 0.0.130

package/dist/usebeeline.mjs

@@ -1080,6 +1080,7 @@ var init_agent_command = __esm({
 
 // apps/body/dist/squire-host.js
 import { spawn as spawn5 } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync as existsSync5, lstatSync, mkdirSync } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir2 } from "node:os";
@@ -1120,8 +1121,16 @@ function squireBrokerSocketReady(socketPath) {
     return false;
   }
 }
-function squireFacadeLaunch(home) {
-  const env = squireHostRewriteEnv(home);
+function squireAgentIdentity({ agentId, roomId }) {
+  if (!agentId || !roomId)
+    throw new Error("Squire agent and Room IDs are required");
+  return `beeline:${createHash("sha256").update(JSON.stringify([agentId, roomId])).digest("hex")}`;
+}
+function squireFacadeLaunch(home, scope) {
+  const env = {
+    ...squireHostRewriteEnv(home),
+    TRUSTY_SQUIRE_AGENT_IDENTITY: squireAgentIdentity(scope)
+  };
   const meta = "usebeeline:npm";
   if (meta.startsWith("beeline:")) {
     const entry = process.argv[1];
@@ -3478,7 +3487,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes8, createHash: createHash10 } = __require("crypto");
+    var { randomBytes: randomBytes8, createHash: createHash11 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -4146,7 +4155,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash10("sha1").update(key + GUID).digest("base64");
+        const digest = createHash11("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4515,7 +4524,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash10 } = __require("crypto");
+    var { createHash: createHash11 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -4822,7 +4831,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash10("sha1").update(key + GUID).digest("base64");
+        const digest = createHash11("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -22072,7 +22081,7 @@ __export(self_update_exports, {
   writeUpdateAttemptFixture: () => writeUpdateAttemptFixture,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
 import { access as access2, chmod as chmod7, lstat as lstat4, mkdir as mkdir19, open, readFile as readFile15, rename as rename7, rm as rm9, symlink as symlink3, writeFile as writeFile14 } from "node:fs/promises";
 import { spawn as spawn10 } from "node:child_process";
@@ -22305,7 +22314,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (!response.ok || !response.body) {
       throw new Error(`downloading ${published.file} failed: HTTP ${response.status}`);
     }
-    const hash = createHash8("sha256");
+    const hash = createHash9("sha256");
     const chunks = [];
     for await (const chunk of response.body) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -22667,7 +22676,7 @@ var init_self_update = __esm({
         if (previousAttempt?.status === "reverted" && !opts.force) {
           const sameCommit = Boolean(previousAttempt.to.commit && previousAttempt.to.commit === bundle.commit);
           const sameVersion = Boolean(previousAttempt.to.version && previousAttempt.to.version === bundle.version);
-          if (sameCommit || sameVersion) {
+          if (sameCommit && sameVersion) {
             const line = `release ${describeIdentity(previousAttempt.to)} reverted after a failed served-turn proof; waiting for a newer publish or \`beeline update --force\``;
             if (line !== this.lastVerdictLog) {
               this.log(`[body] self-update: ${line}`);
@@ -26737,13 +26746,13 @@ async function applyRuntimeModelPreflight(config, agent, selection, validate = v
 }
 
 // apps/body/dist/model-catalog-sync.js
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 var MODEL_CATALOG_PROBE_TIMEOUT_MS = 3e4;
 var MODEL_CATALOG_HASH_FILE = "model-catalog.sha256";
 function modelCatalogHash(options, selection, startupUnavailable) {
-  return createHash("sha256").update(JSON.stringify({
+  return createHash2("sha256").update(JSON.stringify({
     options,
     selection: selection ?? null,
     startupUnavailable: startupUnavailable ?? null
@@ -27963,7 +27972,7 @@ var StdioSquireMcpClient = class {
   initialized;
   closed = false;
   log;
-  constructor(options = {}) {
+  constructor(options) {
     this.options = options;
     this.log = options.log ?? (() => {
     });
@@ -28007,8 +28016,13 @@ var StdioSquireMcpClient = class {
     return this.initialized;
   }
   initialize() {
-    const launch = squireFacadeLaunch(homedir4());
-    const child = (this.options.spawn ?? spawn8)(this.options.command ?? launch.command, [...this.options.args ?? launch.args], { env: this.options.env ?? { ...squireConnectProcessEnv(), ...launch.env } });
+    const launch = squireFacadeLaunch(homedir4(), this.options.scope);
+    const child = (this.options.spawn ?? spawn8)(this.options.command ?? launch.command, [...this.options.args ?? launch.args], {
+      env: {
+        ...this.options.env ?? { ...squireConnectProcessEnv(), ...launch.env },
+        TRUSTY_SQUIRE_AGENT_IDENTITY: launch.env.TRUSTY_SQUIRE_AGENT_IDENTITY
+      }
+    });
     this.child = child;
     this.buffer = "";
     child.stdout.setEncoding("utf8");
@@ -28085,12 +28099,12 @@ var StdioSquireMcpClient = class {
     }
   }
 };
-function defaultSquireMcpClient() {
-  return new StdioSquireMcpClient();
+function defaultSquireMcpClient(scope) {
+  return new StdioSquireMcpClient({ scope });
 }
 
 // apps/body/dist/registry-mcp.js
-import { createHash as createHash2, randomBytes } from "node:crypto";
+import { createHash as createHash3, randomBytes } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import { createRequire as createRequire4 } from "node:module";
 import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -28101,13 +28115,28 @@ import { createInterface as createInterface4 } from "node:readline";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // apps/body/dist/mcp-route-class.js
+import { isIP } from "node:net";
 var CODE_OWNED_HOST_MCP_NAMES = ["squire"];
 var MCP_ROUTE_CLASS_KEY = "beeline_route";
 var MCP_ROUTE_HOST = "host";
 function isCodeOwnedHostMcpName(name) {
   return CODE_OWNED_HOST_MCP_NAMES.includes(name.trim().toLowerCase());
 }
-function classifyImportedMcpServer(_input) {
+function classifyImportedMcpServer(input) {
+  const declaration = input.declaration;
+  if (!declaration || isCodeOwnedHostMcpName(input.name))
+    return "host";
+  const publicKeys = /* @__PURE__ */ new Set(["url", "enabled", "startup_timeout_sec", "tool_timeout_sec"]);
+  if (Object.keys(declaration).some((key) => !publicKeys.has(key)))
+    return "host";
+  if (typeof declaration.url !== "string")
+    return "host";
+  try {
+    const url = new URL(declaration.url);
+    if (url.protocol === "https:" && url.hostname.includes(".") && !url.hostname.endsWith(".local") && !isIP(url.hostname) && !url.username && !url.password && !url.search && !url.hash)
+      return "local";
+  } catch {
+  }
   return "host";
 }
 function hasSquireBrokerEnvironment(declaration) {
@@ -28458,7 +28487,7 @@ async function installRegistryMcp(input) {
       if (typeof client.client_id !== "string")
         throw new Error("dynamic client registration returned no client id");
       const verifier = base64url(randomBytes(48));
-      const challenge3 = base64url(createHash2("sha256").update(verifier).digest());
+      const challenge3 = base64url(createHash3("sha256").update(verifier).digest());
       const resourceIndicator = safeUrl(resource.resource) ?? remoteUrl;
       const scope = Array.isArray(resource.scopes_supported) ? resource.scopes_supported.filter((item) => typeof item === "string").join(" ") : challengeParameter(initialize.headers.get("www-authenticate"), "scope");
       const authorizationUrl = new URL(authorizationEndpoint);
@@ -29004,7 +29033,7 @@ var ConnectorAssignmentLoop = class {
     })();
   }
   squire() {
-    this.mcp ??= defaultSquireMcpClient();
+    this.mcp ??= defaultSquireMcpClient({ agentId: this.agentId, roomId: "connector" });
     return this.mcp;
   }
   async handle(assignment) {
@@ -30053,6 +30082,7 @@ var DaemonApiClient = class {
   connectorAssignmentListener;
   cornerCompleteListener;
   cornerRestartListener;
+  helperReleaseListener;
   constructor(baseUrl, daemonToken, agentId, fetchImpl = fetch, webSocketFactory = (url, protocols) => new wrapper_default(url, protocols)) {
     this.baseUrl = baseUrl;
     this.daemonToken = daemonToken;
@@ -30127,6 +30157,9 @@ var DaemonApiClient = class {
   setCornerRestartListener(listener) {
     this.cornerRestartListener = listener;
   }
+  setHelperReleaseListener(listener) {
+    this.helperReleaseListener = listener;
+  }
   updateLiveCursor(roomId, cursor3) {
     const room = this.liveRooms.get(roomId);
     if (room && cursor3)
@@ -30180,6 +30213,10 @@ var DaemonApiClient = class {
       if (!value || typeof value !== "object")
         return;
       const event = value;
+      if (event.type === "helper-release" && typeof event.version === "string" && typeof event.sha === "string") {
+        this.helperReleaseListener?.({ version: event.version, sha: event.sha });
+        return;
+      }
       if (event.type === "rooms-changed") {
         this.roomsChangedListener?.(membershipChange(event));
         return;
@@ -30321,7 +30358,7 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 
 // apps/body/dist/room-runtime.js
 import { execFile as execFile9 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
 import { mkdir as mkdir15, realpath as realpath2, rm as rm7 } from "node:fs/promises";
 import { dirname as dirname15, relative as relative3, resolve as resolve25, sep as sep2 } from "node:path";
@@ -30329,7 +30366,7 @@ import { promisify as promisify5 } from "node:util";
 
 // apps/body/dist/grant-runner.js
 import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash3, randomBytes as randomBytes7 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes7 } from "node:crypto";
 import { readFile as readFile5 } from "node:fs/promises";
 import { createServer as createServer2 } from "node:http";
 import { dirname as dirname8, resolve as resolve12 } from "node:path";
@@ -31260,7 +31297,7 @@ ${ROOM_WRITE_REFUSED_NOTE}` : outcome.output, secrets), cap);
     if (!script || script.path !== argument.path) {
       throw new Error(`${argument.path} is a script no human has read: this grant was approved without it. Ask with request_grant kind=command so the card carries what the command runs.`);
     }
-    if (createHash3("sha256").update(bytes).digest("hex") !== script.sha256) {
+    if (createHash4("sha256").update(bytes).digest("hex") !== script.sha256) {
       throw new Error(`${argument.path} changed after it was approved, so the approval no longer covers it. Ask with request_grant kind=command again so a human reads what runs now.`);
     }
   }
@@ -31816,7 +31853,7 @@ async function runServerCommandIntake(options) {
 
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile8 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { mkdir as mkdir14, readFile as readFile12, writeFile as writeFile11 } from "node:fs/promises";
 import { homedir as homedir11, hostname as hostname2 } from "node:os";
 import { dirname as dirname14, join as join13, resolve as resolve24 } from "node:path";
@@ -32621,7 +32658,7 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // apps/body/dist/agent-home.js
-import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
 import { chmod as chmod3, copyFile, lstat as lstat2, mkdir as mkdir6, readFile as readFile9, readlink, readdir as readdir3, realpath, rename as rename3, rm as rm4, symlink, unlink as unlink3, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
 import { basename as basename4, dirname as dirname10, join as join9, relative as relative2, resolve as resolve17, sep } from "node:path";
@@ -32763,7 +32800,7 @@ var BEELINE_ROOM_CAPABILITIES = [
   "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.",
   "If a shell command is refused, say so plainly rather than retrying it, and continue with read-only inspection: call beeline-readonly-mcp.search_text to find code and beeline-readonly-mcp.read_file to read it. Use CodeGraph first when it is available for indexed code relationships.",
-  "A mounted tool is not standing resource consent: each resource call checks the original requester. Repository permission under yolo bypasses prompts for anyone; personal resources bypass only for their owner requester. Otherwise repository asks go to Workspace managers in the Room and resource asks go privately to the resource owner. Approved resource access includes paid calls within its scope, without a generic budget card. Delegation and follow-up work retain the original requester. Network web search is enabled.",
+  "An agent may use its own owner\u2019s tools and resources regardless of who started the turn or whether yolo is on. Access to another person\u2019s files or tools outside the sandbox asks that resource owner. Wallet access keeps its separate approval rule. The two command hard stops remain: credential files named by argv and scripts nobody has read. Delegation and follow-up work retain the original requester. Network web search is enabled.",
   BEELINE_AMBIENT_CONNECTOR_CAPABILITY,
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
   "To create a file you can send, call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent post_artifact with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote), or with html/bytes content directly; it is uploaded and attached to your reply, and title and mime default from the file when you post by path. write_scratch_file produces the file, not a picture. To put a real photograph in an artifact, call beeline-agent fetch_image with the photo URL; it writes the bytes to your session scratch and returns the path, mime, and size \u2014 read them, base64-encode, and embed as a data: URL. The validator still refuses every http(s) image reference, and drawing an SVG stand-in is not a photograph.",
@@ -32782,7 +32819,7 @@ var BEELINE_DM_CAPABILITIES = [
   "This is a private direct-message conversation with one person. Every message they send is addressed to you; reply without tagging.",
   "This Room is strictly conversational: there is no repository binding and no corner can be opened from here.",
   "The repository filesystem is read-only in this session.",
-  "A mounted tool is not standing resource consent: each resource call checks the original requester. Repository permission under yolo bypasses prompts for anyone; personal resources bypass only for their owner requester. Otherwise repository asks go to Workspace managers in the Room and resource asks go privately to the resource owner. Approved resource access includes paid calls within its scope, without a generic budget card. Delegation and follow-up work retain the original requester. Network web search is enabled.",
+  "An agent may use its own owner\u2019s tools and resources regardless of who started the turn or whether yolo is on. Access to another person\u2019s files or tools outside the sandbox asks that resource owner. Wallet access keeps its separate approval rule. The two command hard stops remain: credential files named by argv and scripts nobody has read. Delegation and follow-up work retain the original requester. Network web search is enabled.",
   BEELINE_AMBIENT_CONNECTOR_CAPABILITY,
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
   "To create a file you can send, call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent post_artifact with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote), or with html/bytes content directly; it is uploaded and attached to your reply, and title and mime default from the file when you post by path. write_scratch_file produces the file, not a picture. To put a real photograph in an artifact, call beeline-agent fetch_image with the photo URL; it writes the bytes to your session scratch and returns the path, mime, and size \u2014 read them, base64-encode, and embed as a data: URL. The validator still refuses every http(s) image reference, and drawing an SVG stand-in is not a photograph.",
@@ -33201,14 +33238,14 @@ function grantedSquireHostRouteNames(granted, declarations = {}) {
 function hostRouteEnv(hostHome) {
   return { XDG_CONFIG_HOME: join8(resolve15(hostHome), ".config") };
 }
-function rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile) {
+function rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile, squireScope) {
   const next = { ...declaration };
   delete next[MCP_ROUTE_CLASS_KEY];
   const explicitResourceTarget = typeof next[MCP_RESOURCE_TARGET_KEY] === "string" ? next[MCP_RESOURCE_TARGET_KEY] : void 0;
   const transportGate = next[MCP_RESOURCE_GATE_KEY] === MCP_RESOURCE_GATE_TRANSPORT;
   delete next[MCP_RESOURCE_TARGET_KEY];
   delete next[MCP_RESOURCE_GATE_KEY];
-  const launch = isSquireDeclaration(name, declaration) ? squireFacadeLaunch(hostHome) : void 0;
+  const launch = isSquireDeclaration(name, declaration) ? squireFacadeLaunch(hostHome, requiredSquireScope(squireScope)) : void 0;
   const routeEnv = launch?.env ?? hostRouteEnv(hostHome);
   const gooseShape = "cmd" in declaration && !("command" in declaration);
   if (launch) {
@@ -33240,7 +33277,12 @@ function rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile
   }
   return next;
 }
-function rewriteGrantedHostRoutes(declarations, granted, hostHome, resourceAuthFile) {
+function requiredSquireScope(scope) {
+  if (!scope)
+    throw new Error("Squire agent and Room scope is required");
+  return scope;
+}
+function rewriteGrantedHostRoutes(declarations, granted, hostHome, resourceAuthFile, squireScope) {
   const allowed = new Set(granted);
   const rewritten = {};
   for (const [name, declaration] of Object.entries(declarations)) {
@@ -33248,17 +33290,17 @@ function rewriteGrantedHostRoutes(declarations, granted, hostHome, resourceAuthF
       continue;
     if (classifyImportedMcpServer({ name, declaration }) !== "host")
       continue;
-    rewritten[name] = rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile);
+    rewritten[name] = rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile, squireScope);
   }
   for (const name of granted) {
     if (rewritten[name] || !isCodeOwnedHostMcpName(name))
       continue;
-    rewritten[name] = rewriteHostMcpDeclaration(name, {}, hostHome, resourceAuthFile);
+    rewritten[name] = rewriteHostMcpDeclaration(name, {}, hostHome, resourceAuthFile, squireScope);
   }
   return rewritten;
 }
-function grantedHostRouteWires(granted, hostHome, declarations = {}, resourceAuthFile) {
-  const routes = rewriteGrantedHostRoutes(declarations, granted, hostHome, resourceAuthFile);
+function grantedHostRouteWires(granted, hostHome, declarations = {}, resourceAuthFile, squireScope) {
+  const routes = rewriteGrantedHostRoutes(declarations, granted, hostHome, resourceAuthFile, squireScope);
   return Object.entries(routes).flatMap(([name, declaration]) => {
     const command = typeof declaration.command === "string" && declaration.command || typeof declaration.cmd === "string" && declaration.cmd || "";
     if (!command)
@@ -34043,7 +34085,7 @@ async function prepareRoomAgentHome(input) {
     console.error(`[body] could not repair shared credentials under ${root}:`, error);
   }
   const prior = agentHomeProvisionQueues.get(root) ?? Promise.resolve();
-  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed === true || Boolean(input.resourceAuthFile), input.sharedSkills ?? [], agentSkillDir(input.agentKind), input.openRouterRouting, input.isReviewer ?? false, input.grantedHostRoutes ?? [], input.extraHostRoutes ?? {}, input.agentKind, input.resourceAuthFile));
+  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed === true || Boolean(input.resourceAuthFile), input.sharedSkills ?? [], agentSkillDir(input.agentKind), input.openRouterRouting, input.isReviewer ?? false, input.grantedHostRoutes ?? [], input.extraHostRoutes ?? {}, input.agentKind, input.resourceAuthFile, input.squireScope));
   agentHomeProvisionQueues.set(root, provision);
   try {
     await provision;
@@ -34053,7 +34095,7 @@ async function prepareRoomAgentHome(input) {
   }
   return roomAgentHomeEnv(root);
 }
-async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting, isReviewer, grantedHostRoutes, extraHostRoutes, agentKind, resourceAuthFile) {
+async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting, isReviewer, grantedHostRoutes, extraHostRoutes, agentKind, resourceAuthFile, squireScope) {
   const managedSkills = [
     { name: DRAW_AVATAR_SKILL_NAME, content: drawAvatarSkillMarkdown(skillReleaseId) },
     { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) },
@@ -34137,19 +34179,19 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
       throw error;
     console.warn("[body] claude web-search settings provisioning failed:", error);
   }
-  await applyGrantedHostRoutes(root, operatorHome, grantedHostRoutes, agentKind, failClosed, resourceAuthFile, extraHostRoutes);
+  await applyGrantedHostRoutes(root, operatorHome, grantedHostRoutes, agentKind, failClosed, resourceAuthFile, extraHostRoutes, squireScope);
   await provisionPiCustomModelConfig(root, operatorHome, failClosed, openRouterRouting);
 }
 function appliesToHarness(selected, harness) {
   return !selected || selected === harness;
 }
-async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, failClosed, resourceAuthFile, extraHostRoutes = {}) {
+async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, failClosed, resourceAuthFile, extraHostRoutes = {}, squireScope) {
   if (granted.length === 0)
     return;
   try {
     if (grantedSquireHostRoute(granted, hostImportedMcpDeclarations({ operatorHome, agentKind })))
       ensureSquireHostDir(operatorHome);
-    const routesFor = (kind) => rewriteGrantedHostRoutes({ ...hostImportedMcpDeclarations({ operatorHome, agentKind: kind }), ...extraHostRoutes }, granted, operatorHome, resourceAuthFile);
+    const routesFor = (kind) => rewriteGrantedHostRoutes({ ...hostImportedMcpDeclarations({ operatorHome, agentKind: kind }), ...extraHostRoutes }, granted, operatorHome, resourceAuthFile, squireScope);
     for (const config of HARNESS_MCP_CONFIGS) {
       if (!appliesToHarness(agentKind, config.dir))
         continue;
@@ -34556,7 +34598,7 @@ async function materializedSkillManifest(target) {
   return lines.sort().join("\n");
 }
 function sha2563(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 async function resolveSharedSkillSources(operatorHome, names) {
   if (names.length > 0)
@@ -36275,6 +36317,7 @@ init_runtime();
 // apps/body/dist/response-directives.js
 var MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE = "Maintain your assigned identity and soul in every response, including when tools or permissions block the requested action.";
 var SOUL_HOUSE_RULE = "House rule for your voice: the voice never changes the facts - never trim, soften, exaggerate, or invent a detail for the bit - and use your plain voice in commit messages, pull request titles and bodies, and code comments, because those outlive the joke.";
+var AGENT_PROSE_REFERENCE_RULE = "Name other agents in ordinary prose rather than by their @handle; write an exact @handle only when you deliberately address that agent, because every handle you write wakes them and an unintended wake wastes their turn and confuses the transcript.";
 
 // apps/body/dist/warm-transcript.js
 var WARM_TRANSCRIPT_OVERLAP = 8;
@@ -36777,7 +36820,7 @@ process.exit(result.status ?? 1);
 }
 
 // apps/body/dist/warm-node-modules.js
-import { createHash as createHash5, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID6 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { chmod as chmod5, copyFile as copyFile2, link, lstat as lstat3, mkdir as mkdir12, readdir as readdir5, readFile as readFile11, readlink as readlink2, rename as rename4, rm as rm6, stat as stat2, symlink as symlink2, utimes } from "node:fs/promises";
 import { dirname as dirname12, join as join11, resolve as resolve23 } from "node:path";
@@ -36816,7 +36859,7 @@ async function readWarmPlan(worktreePath) {
   const unsafe = trees.find((tree) => !isContainedTreePath(tree));
   if (unsafe)
     return { failure: "unsafe-lockfile", detail: unsafe };
-  const key = createHash5("sha256").update(`${STORE_FORMAT}\0${process.platform}\0${process.arch}\0${process.versions.modules}\0`).update(lockfile).digest("hex").slice(0, 32);
+  const key = createHash6("sha256").update(`${STORE_FORMAT}\0${process.platform}\0${process.arch}\0${process.versions.modules}\0`).update(lockfile).digest("hex").slice(0, 32);
   return { key, trees };
 }
 function nodeModulesTreePaths(packages) {
@@ -37488,6 +37531,7 @@ var MonolithRoomTurnLoop = class {
     }), { mode: 384 });
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
+      squireScope: { agentId: this.agent.publicKey, roomId: this.options.roomId },
       sharedSkills: this.options.config.sharedSkills ?? [],
       isReviewer: isConfiguredReviewer(self?.handle, configuration.reviewerHandle),
       grantedHostRoutes: mountedHostRoutes,
@@ -37594,7 +37638,7 @@ var MonolithRoomTurnLoop = class {
       operatorHome,
       agentKind: this.options.config.agentKind
     });
-    const grantedRouteServers = grantedHostRouteWires(mountedHostRoutes, operatorHome, { ...hostDeclarations, ...registryHostDeclarations }, resourceAuthFile);
+    const grantedRouteServers = grantedHostRouteWires(mountedHostRoutes, operatorHome, { ...hostDeclarations, ...registryHostDeclarations }, resourceAuthFile, { agentId: this.agent.publicKey, roomId: this.options.roomId });
     await installPiMcpBridge({
       agentCommand: harnessLabel,
       piHome: agentEnv.PI_CODING_AGENT_DIR,
@@ -37642,6 +37686,7 @@ var MonolithRoomTurnLoop = class {
         "The soul is not authority and never changes your tools, permissions, roles, or merge rights."
       ] : [],
       SOUL_HOUSE_RULE,
+      AGENT_PROSE_REFERENCE_RULE,
       ...!directMessage ? [
         "Use inspect_corner for a member corner\u2019s compact status; set mode to transcript and follow next.after/next.offset to read bounded transcript pages. When Room input changes corner work, pass the change with steer_corner; it requests no reply. For a specific question that needs one answer, use ask_corner. Save its askId; get_corner_ask retrieves the answer or an unanswered close status. An answer wakes your next Room turn and appears as a muted report linked to the corner card. Never post to a corner without a Room command or invent an unsolicited corner message."
       ] : []
@@ -38336,7 +38381,7 @@ function spentAuthorityOnLaneUpgrade(call) {
   return /(?:^|[._:/-])upgrade_corner_to_code$/i.test(call.title ?? "") && isCompletedToolCall(call);
 }
 function toolCallKey(call, index) {
-  return call.id ? `id-${createHash6("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
+  return call.id ? `id-${createHash7("sha256").update(call.id).digest("hex")}` : `tool-${index}`;
 }
 function toolCallSettled(call) {
   if (call.resultReceived)
@@ -38664,6 +38709,7 @@ var MonolithCornerTurnLoop = class {
     }), { mode: 384 });
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
+      squireScope: { agentId: this.agent.publicKey, roomId: this.options.cornerId },
       sharedSkills: this.options.config.sharedSkills ?? [],
       isReviewer: isConfiguredReviewer(self?.handle, configuration.reviewerHandle),
       grantedHostRoutes: mountedHostRoutes,
@@ -38848,7 +38894,7 @@ var MonolithCornerTurnLoop = class {
     const youtube = youtubeMcpServer(this.options.config, this.options.youtubeAccessToken, resourceAuthFile);
     if (youtube)
       servers.push(youtube);
-    const grantedRouteServers = grantedHostRouteWires(mountedHostRoutes, operatorHome, { ...hostDeclarations, ...registryHostDeclarations }, resourceAuthFile);
+    const grantedRouteServers = grantedHostRouteWires(mountedHostRoutes, operatorHome, { ...hostDeclarations, ...registryHostDeclarations }, resourceAuthFile, { agentId: this.agent.publicKey, roomId: this.options.cornerId });
     await installPiMcpBridge({
       agentCommand: harnessLabel,
       piHome: agentEnv.PI_CODING_AGENT_DIR,
@@ -38858,7 +38904,8 @@ var MonolithCornerTurnLoop = class {
     const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
       ...persona?.instructions ? [`Human-authored Workspace persona: ${persona.name}. ${persona.instructions}`] : [],
-      SOUL_HOUSE_RULE
+      SOUL_HOUSE_RULE,
+      AGENT_PROSE_REFERENCE_RULE
     ].join("\n");
     this.turnIdentityInstructions = harnessHonorsSessionSystemPrompt(command) ? "" : [identityInstructions, personaInstructions].filter(Boolean).join("\n\n");
     const opened = await this.client.sessionNew({
@@ -39091,7 +39138,7 @@ var MonolithCornerTurnLoop = class {
           const delivered = this.attachmentDir && allAttachments.length ? await deliverAttachments(allAttachments, join13(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : [];
           const briefFileLines = await Promise.all((restored.brief?.attachments ?? []).map(async (file, index) => {
             const entry = delivered.find((item) => item.attachment === briefAttachments[index]);
-            const verified = entry?.path && createHash6("sha256").update(await readFile12(entry.path)).digest("hex") === file.sha256;
+            const verified = entry?.path && createHash7("sha256").update(await readFile12(entry.path)).digest("hex") === file.sha256;
             return `- ${file.title} (${file.purpose}; ${file.required ? "required" : "optional"}; sha256 ${file.sha256}): ${verified ? entry.path : "UNAVAILABLE OR CONTENT MISMATCH"}`;
           }));
           const missingRequiredBriefFile = (restored.brief?.attachments ?? []).some((file, index) => file.required && briefFileLines[index]?.includes("UNAVAILABLE OR CONTENT MISMATCH"));
@@ -40012,7 +40059,7 @@ function cornerStartConfigKey(repository, objective) {
 }
 function cornerRepositoryCacheDir(supervisorRoot, remote) {
   const normalizedRemote = roomCheckoutRemote(remote);
-  const repositoryHash = createHash7("sha256").update(normalizedRemote).digest("hex").slice(0, 24);
+  const repositoryHash = createHash8("sha256").update(normalizedRemote).digest("hex").slice(0, 24);
   return resolve25(supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
 }
 function isStandingCornerStartFault(error) {
@@ -40689,7 +40736,7 @@ var RoomRuntimeCoordinator = class {
       return this.roomRoot(roomId);
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
-    const checkoutId = createHash7("sha256").update(`${roomId}\0${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
+    const checkoutId = createHash8("sha256").update(`${roomId}\0${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
     const path = resolve25(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
     await mkdir15(dirname15(path), { recursive: true, mode: 448 });
     const token = remote.startsWith("https://github.com/") ? await this.options.daemonApi.execute("getRoomGitHubToken", { roomId }) : void 0;
@@ -41330,21 +41377,332 @@ init_runtime();
 init_launchd();
 init_systemd();
 import { spawn as spawn11 } from "node:child_process";
-import { mkdir as mkdir21, rm as rm10, stat as stat5, writeFile as writeFile16 } from "node:fs/promises";
-import { dirname as dirname21, resolve as resolve31 } from "node:path";
+import { mkdir as mkdir22, rm as rm11, stat as stat5, writeFile as writeFile16 } from "node:fs/promises";
+import { dirname as dirname21, resolve as resolve32 } from "node:path";
+
+// apps/body/dist/update-functional-probe.js
+import { mkdir as mkdir20, rm as rm10 } from "node:fs/promises";
+import { homedir as homedir15 } from "node:os";
+import { resolve as resolve30 } from "node:path";
+init_cursor_acp_bridge();
+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) {
+  return code === -32603 || code <= -32e3 && code >= -32099;
+}
+function classifyAcpTurnFailure(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
+  if (!message)
+    return void 0;
+  if (ACP_PROMPT_INACTIVITY.test(message))
+    return { kind: "prompt-inactivity" };
+  const code = Number(ACP_ERROR_CODE.exec(message)?.[1]);
+  if (Number.isFinite(code) && isServerInternalCode(code))
+    return { kind: "server-internal", code };
+  return void 0;
+}
+function sameAcpTurnFailure(one, other) {
+  if (one.kind === "server-internal") {
+    return other.kind === "server-internal" && one.code === other.code;
+  }
+  return other.kind === one.kind;
+}
+var UpdateFunctionalProbeError = class extends Error {
+  reason;
+  code = "BEELINE_UPDATE_FUNCTIONAL_PROBE_FAILED";
+  /** Present when the turn failed on a provider refusal with an HTTP status. */
+  providerRefusal;
+  constructor(reason, detail, options) {
+    super(`functional update probe failed (${reason}): ${detail}`, options);
+    this.reason = reason;
+    this.name = "UpdateFunctionalProbeError";
+    this.providerRefusal = options?.providerRefusal;
+  }
+};
+async function probeOutcome(run2) {
+  try {
+    await run2();
+    return { kind: "served" };
+  } catch (error) {
+    if (error instanceof UpdateFunctionalProbeError && error.reason === "sandbox-unavailable") {
+      return { kind: "sandbox-unavailable", reason: error.message };
+    }
+    if (error instanceof UpdateFunctionalProbeError && error.providerRefusal) {
+      return { kind: "refused", ...error.providerRefusal };
+    }
+    return { kind: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function describeCurrentReleaseOutcome(outcome) {
+  switch (outcome.kind) {
+    case "served":
+      return "the current release answered";
+    case "refused":
+      return `the current release got a different refusal (${outcome.reason})`;
+    case "sandbox-unavailable":
+      return `the current release has the same unavailable sandbox (${outcome.reason})`;
+    case "model-unavailable":
+      return `the current release cannot serve that model either (${outcome.reason})`;
+    case "unavailable":
+      return `the current release could not be compared (${outcome.reason})`;
+  }
+}
+async function runUpdateFunctionalProbe(input) {
+  const command = input.config.agentCommand ?? input.config.agentBinary;
+  const harnessLabel = harnessIdentityLabel({
+    kind: input.config.agentKind,
+    command
+  });
+  const harness = input.config.agentKind ?? command;
+  if (input.config.modelUnavailable) {
+    const detail = input.config.modelUnavailable.detail;
+    if (!input.compareWithCurrentRelease) {
+      throw new UpdateFunctionalProbeError("model-unavailable", detail);
+    }
+    const current = await input.compareWithCurrentRelease({
+      kind: "model-unavailable",
+      reason: detail
+    });
+    if (current.kind !== "model-unavailable" && current.kind !== "unavailable") {
+      throw new UpdateFunctionalProbeError("model-unavailable", `${detail}; ${describeCurrentReleaseOutcome(current)}`);
+    }
+    console.warn("[body] update probe: the configured model is unavailable to this release and the current release alike; that is the account catalog, not the bundle, so the probe passes without a model answer");
+    return {
+      harness,
+      sandboxed: false,
+      sessionStarted: false,
+      turnCompleted: false,
+      nativeTools: [],
+      modelAnswer: "unavailable",
+      modelAnswerReason: `${detail} (the current release cannot serve that model either)`
+    };
+  }
+  if (input.sandboxRequired && !input.config.bwrapPath) {
+    const detail = input.sandboxUnavailableDetail ?? "the configured bubblewrap boundary did not pass its startup self-test";
+    if (!input.compareWithCurrentRelease) {
+      throw new UpdateFunctionalProbeError("sandbox-unavailable", detail);
+    }
+    const current = await input.compareWithCurrentRelease({
+      kind: "sandbox-unavailable",
+      reason: detail
+    });
+    if (current.kind !== "sandbox-unavailable") {
+      throw new UpdateFunctionalProbeError("sandbox-unavailable", `${detail}; ${describeCurrentReleaseOutcome(current)}`);
+    }
+    console.warn("[body] update probe: the sandbox is unavailable to this release and the current release alike; preserving fail-closed sandboxing and accepting the bundle as inconclusive");
+    return {
+      harness,
+      sandboxed: false,
+      sessionStarted: false,
+      turnCompleted: false,
+      nativeTools: [],
+      modelAnswer: "unavailable",
+      modelAnswerReason: `${detail} (the current release has the same host sandbox failure)`
+    };
+  }
+  const root = input.probeRoot ?? resolve30(input.runtimeDir, "update-functional-probe");
+  const cwd = resolve30(root, "checkout");
+  const homeRoot = resolve30(root, "agent-home");
+  await rm10(root, { recursive: true, force: true });
+  await mkdir20(cwd, { recursive: true, mode: 448 });
+  let client;
+  try {
+    const agentEnv = {
+      ...input.config.agentEnv,
+      ...await prepareRoomAgentHome({
+        root: homeRoot,
+        operatorHome: input.config.operatorHome ?? homedir15(),
+        sharedSkills: input.config.sharedSkills ?? [],
+        ...input.config.agentKind ? { agentKind: input.config.agentKind } : {},
+        skillReleaseId: input.releaseId,
+        failClosed: true,
+        ...openRouterRoutingInput({ ...input.config, openRouterRoutingCacheDir: openRouterRoutingCacheDir(input.runtimeDir) }, input.config.modelSelection)
+      })
+    };
+    const selectedAgent = {
+      kind: input.config.agentKind,
+      command,
+      args: input.config.agentArgs ?? []
+    };
+    let spawnCommand = {
+      command,
+      args: agentArgsWithModelSelection(selectedAgent, input.config.modelSelection)
+    };
+    let modelAnswer = {};
+    let turnCompleted = true;
+    if (input.config.bwrapPath) {
+      const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
+      const operatorHome = input.config.operatorHome ?? homedir15();
+      const homeStateDirs = harnessHomeStateDirs(harnessLabel, agentEnv.HOME ?? operatorHome);
+      await Promise.all(homeStateDirs.map((dir) => mkdir20(dir, { recursive: true })));
+      spawnCommand = wrapAgentCommand({
+        bwrapPath: input.config.bwrapPath,
+        spec: {
+          mode: "readonly",
+          cwd,
+          harnessStateDirs: stateDirs,
+          harnessHomeStateDirs: homeStateDirs,
+          maskPaths: credentialMaskPaths(input.config.sandboxMaskPaths, operatorHome),
+          ...tmpDir ? { tmpDir } : {}
+        },
+        command,
+        args: spawnCommand.args
+      });
+    }
+    client = new AcpClient({
+      agentCommand: spawnCommand.command,
+      agentArgs: spawnCommand.args,
+      agentLabel: harnessLabel,
+      agentEnv,
+      agentCwd: cwd,
+      autoApprovePermissions: true
+    });
+    const sessionTimeoutMs = input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_TIMEOUT_MS;
+    const sessionOpenTimeoutMs = input.sessionOpenTimeoutMs ?? input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS;
+    const openSessionAndPrompt = async () => {
+      const opened = await client.sessionNew({
+        cwd,
+        mcpServers: [],
+        systemPrompt: "This is Beeline update validation. Answer only READY.",
+        mode: "readonly",
+        timeoutMs: sessionOpenTimeoutMs
+      });
+      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 { sessionId, served } = await openSessionAndPrompt();
+        if (served.agentText.trim()) {
+          modelAnswer = { modelAnswer: "served" };
+        } else {
+          const explained = await explainEmptyAgentTurn({
+            agentLabel: harnessLabel,
+            agentEnv,
+            sessionId,
+            result: served
+          });
+          const modelSide = isAccountOrProviderRefusal(explained.record) || explained.record?.kind === "empty";
+          if (!modelSide) {
+            const refusal = explained.record?.kind === "error" && explained.record.status !== void 0 ? { status: explained.record.status, reason: explained.record.reason } : void 0;
+            const detail = `the harness completed a session/prompt without an agent answer: ${explained.reason}`;
+            if (!refusal || !input.compareWithCurrentRelease) {
+              throw new UpdateFunctionalProbeError("turn-failed", detail, {
+                ...refusal ? { providerRefusal: refusal } : {}
+              });
+            }
+            const current = await input.compareWithCurrentRelease({
+              kind: "provider-refusal",
+              reason: refusal.reason,
+              refusal
+            });
+            if (current.kind !== "refused" || current.status !== refusal.status) {
+              throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { providerRefusal: refusal });
+            }
+            const reason = `${explained.reason} (the current release gets the same ${refusal.status})`;
+            console.warn(`[body] update probe: the provider refused this release and the current release alike (${refusal.reason}); that refusal is not this bundle's doing, so the probe passes as inconclusive`);
+            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: reason };
+          } else {
+            console.warn(`[body] update probe: the bundle reached the model boundary but the model answered nothing (${explained.reason}); that is the model's own answer on any release, so the probe passes without one`);
+            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: explained.reason };
+          }
+        }
+      } catch (initialError) {
+        if (initialError instanceof UpdateFunctionalProbeError)
+          throw initialError;
+        if (initialError instanceof ModelSelectionUnavailableError) {
+          throw new UpdateFunctionalProbeError("model-unavailable", initialError.message, {
+            cause: initialError
+          });
+        }
+        let error = initialError;
+        let detail = error instanceof Error ? error.message : String(error);
+        let failure2 = classifyAcpTurnFailure(error);
+        if (failure2) {
+          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(failure2, retryFailure)) {
+              throw new UpdateFunctionalProbeError("turn-failed", retryDetail, {
+                cause: retryError
+              });
+            }
+            error = retryError;
+            detail = retryDetail;
+            failure2 = retryFailure;
+          }
+        }
+        if (error === void 0) {
+        } else if (!failure2 || !input.compareWithCurrentRelease) {
+          throw new UpdateFunctionalProbeError("turn-failed", detail, { cause: error });
+        } else {
+          const current = await input.compareWithCurrentRelease({
+            kind: "acp-turn-failure",
+            reason: detail,
+            failure: failure2
+          });
+          const currentFailure = current.kind === "unavailable" ? classifyAcpTurnFailure(current.reason) : void 0;
+          if (!currentFailure || !sameAcpTurnFailure(failure2, 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)`
+          };
+        }
+      }
+    } catch (error) {
+      if (error instanceof UpdateFunctionalProbeError)
+        throw error;
+      throw new UpdateFunctionalProbeError("session-start-failed", error instanceof Error ? error.message : String(error), { cause: error });
+    }
+    return {
+      harness,
+      sandboxed: Boolean(input.config.bwrapPath),
+      sessionStarted: true,
+      turnCompleted,
+      nativeTools: [],
+      ...modelAnswer
+    };
+  } finally {
+    await client?.stop().catch(() => void 0);
+    await rm10(root, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir20, readFile as readFile16, rename as rename8, unlink as unlink4, writeFile as writeFile15 } from "node:fs/promises";
-import { dirname as dirname20, resolve as resolve30 } from "node:path";
+import { mkdir as mkdir21, readFile as readFile16, rename as rename8, unlink as unlink4, writeFile as writeFile15 } from "node:fs/promises";
+import { dirname as dirname20, resolve as resolve31 } from "node:path";
 var REPORT_INTERVAL_MS = 60 * 60 * 1e3;
 var lastLogged = /* @__PURE__ */ new Map();
 function updateRollbackAlertPath(runtimeDir) {
-  return resolve30(runtimeDir, "update-rollback-alert.json");
+  return resolve31(runtimeDir, "update-rollback-alert.json");
 }
 async function writeAlert(runtimeDir, alert) {
   const path = updateRollbackAlertPath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir20(dirname20(path), { recursive: true });
+  await mkdir21(dirname20(path), { recursive: true });
   await writeFile15(staged, `${JSON.stringify(alert, null, 2)}
 `, { mode: 384 });
   await rename8(staged, path);
@@ -41408,13 +41766,13 @@ var LOCK_STALE_MS = UPDATE_WORKER_DEADLINE_MS + 5 * 6e4;
 var DEFAULT_UPDATE_INITIAL_DELAY_MS = 0;
 async function withInstallLock(layout, work, options = {}) {
   const now2 = options.now ?? Date.now;
-  const lock = resolve31(layout.releasesRoot, ".state", "install.lock");
+  const lock = resolve32(layout.releasesRoot, ".state", "install.lock");
   const deadline = now2() + (options.waitMs ?? 1e4);
-  await mkdir21(dirname21(lock), { recursive: true });
+  await mkdir22(dirname21(lock), { recursive: true });
   for (; ; ) {
     try {
-      await mkdir21(lock);
-      await writeFile16(resolve31(lock, "owner"), `${process.pid}
+      await mkdir22(lock);
+      await writeFile16(resolve32(lock, "owner"), `${process.pid}
 ${now2()}
 `, "utf8");
       break;
@@ -41423,7 +41781,7 @@ ${now2()}
         throw error;
       const age = now2() - await stat5(lock).then((value) => value.mtimeMs).catch(() => now2());
       if (age > LOCK_STALE_MS) {
-        await rm10(lock, { recursive: true, force: true });
+        await rm11(lock, { recursive: true, force: true });
         continue;
       }
       if (now2() >= deadline)
@@ -41434,7 +41792,7 @@ ${now2()}
   try {
     return await work();
   } finally {
-    await rm10(lock, { recursive: true, force: true });
+    await rm11(lock, { recursive: true, force: true });
   }
 }
 var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
@@ -41451,6 +41809,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   #requested = false;
   #restartRequest;
   #stagedReleaseId;
+  #notifiedReleaseKey;
   constructor(options) {
     this.#layout = options.layout;
     this.#loadedRelease = options.loadedRelease;
@@ -41471,6 +41830,13 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       ...options
     });
   }
+  /** The live server socket wakes this install immediately; the manifest stays authoritative. */
+  notifyReleaseAvailable(releaseKey) {
+    if (!releaseKey || this.#notifiedReleaseKey === releaseKey)
+      return;
+    this.#notifiedReleaseKey = releaseKey;
+    this.#nextUpdateCheckAt = 0;
+  }
   /**
    * Return true once either a verified release is staged behind the serving
    * daemon's idle gate or desired-release drift is represented by the single
@@ -41519,9 +41885,15 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
           return;
         const state2 = await readUpdateState(this.#layout);
         const interval = numberEnv(this.#env, "BEELINE_UPDATE_INTERVAL_MS", DEFAULT_UPDATE_INTERVAL_MS);
-        if (state2.lastCheckAt !== void 0 && now2 - state2.lastCheckAt < interval)
+        if (state2.notifiedReleaseKey === this.#notifiedReleaseKey && state2.lastCheckAt !== void 0 && now2 - state2.lastCheckAt < interval)
           return;
         await this.#runUpdateWorker();
+        if (this.#notifiedReleaseKey) {
+          await writeUpdateState(this.#layout, {
+            ...await readUpdateState(this.#layout),
+            notifiedReleaseKey: this.#notifiedReleaseKey
+          });
+        }
       }).catch((error) => {
         console.error(`[thin-core] update worker failed: ${error instanceof Error ? error.message : String(error)}`);
       }).finally(() => {
@@ -41538,7 +41910,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       if (!attempt || attempt.releaseId !== desiredRelease || attempt.status !== "pending") {
         const from = await readInstalledBundleIdentity({
           ...this.#layout,
-          libDir: resolve31(this.#layout.releasesRoot, this.#loadedRelease)
+          libDir: resolve32(this.#layout.releasesRoot, this.#loadedRelease)
         }).catch(() => void 0) ?? {};
         const to = await readInstalledBundleIdentity(this.#layout).catch(() => void 0) ?? {};
         const record6 = {
@@ -41570,7 +41942,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       drainDeadlineAt
     };
     this.#requested = true;
-    console.log(`[thin-core] update restart armed: loaded release ${this.#loadedRelease} -> ${desiredRelease}; absolute drain deadline ${new Date(drainDeadlineAt).toISOString()}`);
+    console.log(`[thin-core] update restart armed: loaded release ${this.#loadedRelease} -> ${desiredRelease}; drain target ${new Date(drainDeadlineAt).toISOString()}`);
     return true;
   }
   /**
@@ -41578,10 +41950,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
    * Busy means a turn is executing right now; serving Rooms and corners with
    * no turn in flight is idle. `quiesceIfIdle` closes intake in the same
    * synchronous transition that proves idle, so a new turn cannot race
-   * activation. A staged release stays inert while a turn runs — until the
-   * absolute drain deadline, when the restart is forced (`forced: true`) and
-   * the caller cancels the running turn; the convergence contract outranks a
-   * stuck turn. `ManagedUpdateDrain` enforces that deadline with a timer.
+   * activation. A staged release stays inert for as long as a turn runs.
    */
   async restartRequest(quiesceIfIdle) {
     const activeDrift = await this.check();
@@ -41590,11 +41959,8 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     const request = this.#restartRequest;
     if (!request)
       throw new Error("update drift was detected without an in-memory restart request");
-    let forced = false;
     if (!quiesceIfIdle()) {
-      if (this.#now() < request.drainDeadlineAt)
-        return { kind: "waiting", request };
-      forced = true;
+      return { kind: "waiting", request };
     }
     if (this.#stagedReleaseId) {
       const stagedReleaseId = this.#stagedReleaseId;
@@ -41627,7 +41993,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       this.#restartRequest = void 0;
       await this.#journalDrift(stagedReleaseId);
     }
-    return { kind: "restart", request: this.#restartRequest ?? request, forced };
+    return { kind: "restart", request: this.#restartRequest ?? request };
   }
 };
 async function coordinateManagedUpdateHandoff(update, quiesceIfIdle, restart, waiting = async () => void 0) {
@@ -41638,23 +42004,20 @@ async function coordinateManagedUpdateHandoff(update, quiesceIfIdle, restart, wa
     await waiting(next.request);
     return "waiting-for-idle";
   }
-  await restart(next.request, next.forced ? "forced" : "drained");
+  await restart(next.request, "drained");
   return "restarting";
 }
 var UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS = 6e4;
 var ManagedUpdateDrain = class {
   #options;
-  #now;
   #log;
   #setTimer;
   #clearTimer;
-  #deadlineTimer;
   #waitLogTimer;
   #resolving;
   #restarting = false;
   constructor(options) {
     this.#options = options;
-    this.#now = options.now ?? Date.now;
     this.#log = options.log ?? ((line) => console.log(line));
     this.#setTimer = options.setTimer ?? ((callback, ms) => setTimeout(callback, ms));
     this.#clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
@@ -41674,49 +42037,39 @@ var ManagedUpdateDrain = class {
     return this.#resolving;
   }
   async #step() {
-    const { update, quiesceIfIdle, activeTurnCount } = this.#options;
+    const { update, quiesceIfIdle } = this.#options;
     let armed;
     const progress = await coordinateManagedUpdateHandoff(update, quiesceIfIdle, async (request, mode) => {
       this.#disarm();
-      if (mode === "forced") {
-        this.#log(`[thin-core] update restart forced: drain deadline reached with ${activeTurnCount()} active turn(s); cancelling them and restarting onto ${request.desiredRelease}`);
-      }
       await this.#options.restart(request, mode);
       this.#restarting = true;
     }, async (request) => {
       armed = request;
       await this.#options.waiting?.(request);
     });
-    if (armed && !this.#deadlineTimer)
-      this.#arm(armed);
+    if (armed && !this.#waitLogTimer)
+      this.#arm();
     return progress;
   }
-  #arm(request) {
-    this.#logWaiting(request);
-    this.#scheduleWaitLog(request);
-    this.#deadlineTimer = this.#setTimer(() => void this.#resolve().catch((error) => {
-      this.#log(`[thin-core] update restart at the drain deadline failed; retrying on the next tick: ${error instanceof Error ? error.message : String(error)}`);
-    }), Math.max(0, request.drainDeadlineAt - this.#now()));
+  #arm() {
+    this.#logWaiting();
+    this.#scheduleWaitLog();
   }
-  #scheduleWaitLog(request) {
+  #scheduleWaitLog() {
     this.#waitLogTimer = this.#setTimer(() => {
       this.#waitLogTimer = void 0;
       if (this.#restarting)
         return;
-      this.#logWaiting(request);
-      this.#scheduleWaitLog(request);
+      this.#logWaiting();
+      this.#scheduleWaitLog();
     }, UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS);
   }
-  #logWaiting(request) {
-    const minutesLeft = Math.max(0, Math.ceil((request.drainDeadlineAt - this.#now()) / 6e4));
-    this.#log(`[thin-core] update restart waiting: ${this.#options.activeTurnCount()} active turn(s); deadline in ${minutesLeft}m`);
+  #logWaiting() {
+    this.#log(`[thin-core] update restart waiting: ${this.#options.activeTurnCount()} active turn(s); will resume after work finishes`);
   }
   #disarm() {
-    if (this.#deadlineTimer !== void 0)
-      this.#clearTimer(this.#deadlineTimer);
     if (this.#waitLogTimer !== void 0)
       this.#clearTimer(this.#waitLogTimer);
-    this.#deadlineTimer = void 0;
     this.#waitLogTimer = void 0;
   }
 };
@@ -41829,16 +42182,17 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
       return false;
     const confirmed = [.../* @__PURE__ */ new Set([...current.confirmedProbeIds ?? [], probeId])].sort();
     const required = current.requiredProbeIds ?? [probeId];
+    const satisfied = [...confirmed, ...current.unavailableProbeIds ?? []];
     await replaceUpdateAttempt(layout, {
       ...current,
       confirmedProbeIds: confirmed,
-      ...required.every((id) => confirmed.includes(id)) ? { status: "confirmed" } : {}
+      ...required.every((id) => satisfied.includes(id)) ? { status: "confirmed" } : {}
     });
     return true;
   });
   if (!accepted)
     return false;
-  await writeFile16(resolve31(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
+  await writeFile16(resolve32(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
     readyAt: (options.now ?? Date.now)(),
     loadedRelease,
     functionalProof: options.functionalProof
@@ -41846,6 +42200,22 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
 `, { mode: 384 });
   return true;
 }
+async function recordUnavailableProbe(input) {
+  return withInstallLock(input.layout, async () => {
+    const current = await readUpdateAttempt(input.layout);
+    if (!current || current.status !== "pending" || current.releaseId !== input.loadedRelease || await activeReleaseId(input.layout) !== input.loadedRelease)
+      return false;
+    const unavailableProbeIds = [.../* @__PURE__ */ new Set([...current.unavailableProbeIds ?? [], input.probeId])].sort();
+    const required = current.requiredProbeIds ?? [input.probeId];
+    const satisfied = [...current.confirmedProbeIds ?? [], ...unavailableProbeIds];
+    await replaceUpdateAttempt(input.layout, {
+      ...current,
+      unavailableProbeIds,
+      ...required.every((id) => satisfied.includes(id)) ? { status: "confirmed" } : {}
+    });
+    return true;
+  });
+}
 function siblingRevertNote(attempt, loadedRelease) {
   if (!loadedRelease || attempt?.releaseId !== loadedRelease || attempt.status !== "reverted") {
     return void 0;
@@ -41877,6 +42247,9 @@ async function gateManagedSuccessor(input) {
     }
     return { kind: "passed", proof };
   } catch (error) {
+    if (error instanceof UpdateFunctionalProbeError && error.reason === "model-unavailable" && await recordUnavailableProbe(input)) {
+      return { kind: "agent-unavailable", error };
+    }
     return {
       kind: "failed",
       error,
@@ -42228,10 +42601,10 @@ async function runStartCommand(args, interactiveUi, dependencyOverrides = {}) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn12 } from "node:child_process";
-import { createHash as createHash9, randomUUID as randomUUID7 } from "node:crypto";
-import { chmod as chmod8, mkdir as mkdir22, readFile as readFile17, unlink as unlink5, writeFile as writeFile17 } from "node:fs/promises";
-import { homedir as homedir15, hostname as hostname3 } from "node:os";
-import { dirname as dirname23, resolve as resolve32 } from "node:path";
+import { createHash as createHash10, randomUUID as randomUUID7 } from "node:crypto";
+import { chmod as chmod8, mkdir as mkdir23, readFile as readFile17, unlink as unlink5, writeFile as writeFile17 } from "node:fs/promises";
+import { homedir as homedir16, hostname as hostname3 } from "node:os";
+import { dirname as dirname23, resolve as resolve33 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 init_access_policy();
 init_agent_command();
@@ -42897,8 +43270,8 @@ function parseConnectSubscriptions(value) {
   ];
 }
 async function readMachineId(env = process.env) {
-  const configDir = resolve32(env.XDG_CONFIG_HOME ?? resolve32(homedir15(), ".config"), "beeline");
-  const machineIdPath = resolve32(configDir, "machine-id");
+  const configDir = resolve33(env.XDG_CONFIG_HOME ?? resolve33(homedir16(), ".config"), "beeline");
+  const machineIdPath = resolve33(configDir, "machine-id");
   let machineId;
   let machineName = hostname3();
   try {
@@ -42909,11 +43282,11 @@ async function readMachineId(env = process.env) {
   } catch {
     machineId = randomUUID7();
     try {
-      await mkdir22(configDir, { recursive: true, mode: 448 });
+      await mkdir23(configDir, { recursive: true, mode: 448 });
       await writeFile17(machineIdPath, `${machineId}
 `, { mode: 384 });
     } catch {
-      machineId = createHash9("sha256").update(machineName).digest("hex").slice(0, 36);
+      machineId = createHash10("sha256").update(machineName).digest("hex").slice(0, 36);
     }
   }
   return { machineId, machineName };
@@ -42922,7 +43295,7 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl, machine
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
-  const avatarSeed = createHash9("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
+  const avatarSeed = createHash10("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
   return jsonRequest(`${baseUrl}/auth/agent/connect`, {
     pairing_code: normalizedPairingCode,
     harness: selection.harness,
@@ -42971,7 +43344,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve32(layout.binDir, "beeline"),
+    binary: resolve33(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -42994,7 +43367,7 @@ function providerEnvironment(selection) {
   };
 }
 async function writePrivateJson(path, value) {
-  await mkdir22(dirname23(path), { recursive: true, mode: 448 });
+  await mkdir23(dirname23(path), { recursive: true, mode: 448 });
   await writeFile17(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
   await chmod8(path, 384);
@@ -43003,8 +43376,8 @@ async function writeProviderEnv(selection, agentPubkey) {
   const values = providerEnvironment(selection);
   if (Object.keys(values).length === 0)
     return void 0;
-  const path = resolve32(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
-  await mkdir22(dirname23(path), { recursive: true, mode: 448 });
+  const path = resolve33(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
+  await mkdir23(dirname23(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
   await writeFile17(path, `${contents}
 `, { mode: 384 });
@@ -43073,7 +43446,7 @@ async function runConnectWizard(code, fetchImpl, eventSubscriptions, accessPolic
   await finishConnectedAgentPairing(baseUrl, pairingCode, grant.workspace_joined, eventSubscriptions, fetchImpl);
   const installedRelease = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl), (release) => `Installed Beeline helper ${release.version}`);
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
-  const grantPath = resolve32(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
+  const grantPath = resolve33(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
@@ -43158,11 +43531,11 @@ async function runConnectFinishCommand(path) {
     throw new Error("connect-finish may run only from the canonical installed Beeline launcher");
   }
   try {
-    const grant = JSON.parse(await readFile17(resolve32(path), "utf8"));
+    const grant = JSON.parse(await readFile17(resolve33(path), "utf8"));
     if (!isDevicePairingGrant(grant))
       throw new Error("device connection grant is invalid");
     const connected = await completeDevicePairing(grant);
-    await unlink5(resolve32(path));
+    await unlink5(resolve33(path));
     const providerEnv = grant.llmEnvFile ? await readFile17(grant.llmEnvFile, "utf8").catch(() => "") : "";
     const apiKey = (/^OPENROUTER_API_KEY=(\S+)/m.exec(providerEnv)?.[1] ?? "").replace(/^["']|["']$/g, "");
     const model = openRouterModelId(grant.model, { OPENROUTER_API_KEY: apiKey });
@@ -43187,12 +43560,12 @@ async function runConnectFinishCommand(path) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir23, readFile as readFile18, rename as rename9, rm as rm11, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname24, resolve as resolve33 } from "node:path";
+import { mkdir as mkdir24, readFile as readFile18, rename as rename9, rm as rm12, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname24, resolve as resolve34 } from "node:path";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
 function daemonFailurePath(runtimeDir) {
-  return resolve33(runtimeDir, "daemon-distress.json");
+  return resolve34(runtimeDir, "daemon-distress.json");
 }
 async function readFailureRecord(runtimeDir) {
   try {
@@ -43208,7 +43581,7 @@ async function readFailureRecord(runtimeDir) {
 async function writeFailureRecord(runtimeDir, record6) {
   const path = daemonFailurePath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir23(dirname24(path), { recursive: true, mode: 448 });
+  await mkdir24(dirname24(path), { recursive: true, mode: 448 });
   await writeFile18(staged, `${JSON.stringify(record6, null, 2)}
 `, { mode: 384 });
   await rename9(staged, path);
@@ -43227,318 +43600,12 @@ async function recordDaemonStartFailure(runtimeDir, error, now2 = Date.now()) {
   return { distressed, count: failures.length, path: daemonFailurePath(runtimeDir) };
 }
 async function clearDaemonStartFailures(runtimeDir) {
-  await rm11(daemonFailurePath(runtimeDir), { force: true });
+  await rm12(daemonFailurePath(runtimeDir), { force: true });
 }
 
 // apps/body/dist/cli.js
 init_systemd();
 
-// apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir24, rm as rm12 } from "node:fs/promises";
-import { homedir as homedir16 } from "node:os";
-import { resolve as resolve34 } from "node:path";
-init_cursor_acp_bridge();
-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) {
-  return code === -32603 || code <= -32e3 && code >= -32099;
-}
-function classifyAcpTurnFailure(error) {
-  const message = error instanceof Error ? error.message : typeof error === "string" ? error : void 0;
-  if (!message)
-    return void 0;
-  if (ACP_PROMPT_INACTIVITY.test(message))
-    return { kind: "prompt-inactivity" };
-  const code = Number(ACP_ERROR_CODE.exec(message)?.[1]);
-  if (Number.isFinite(code) && isServerInternalCode(code))
-    return { kind: "server-internal", code };
-  return void 0;
-}
-function sameAcpTurnFailure(one, other) {
-  if (one.kind === "server-internal") {
-    return other.kind === "server-internal" && one.code === other.code;
-  }
-  return other.kind === one.kind;
-}
-var UpdateFunctionalProbeError = class extends Error {
-  reason;
-  code = "BEELINE_UPDATE_FUNCTIONAL_PROBE_FAILED";
-  /** Present when the turn failed on a provider refusal with an HTTP status. */
-  providerRefusal;
-  constructor(reason, detail, options) {
-    super(`functional update probe failed (${reason}): ${detail}`, options);
-    this.reason = reason;
-    this.name = "UpdateFunctionalProbeError";
-    this.providerRefusal = options?.providerRefusal;
-  }
-};
-async function probeOutcome(run2) {
-  try {
-    await run2();
-    return { kind: "served" };
-  } catch (error) {
-    if (error instanceof UpdateFunctionalProbeError && error.reason === "sandbox-unavailable") {
-      return { kind: "sandbox-unavailable", reason: error.message };
-    }
-    if (error instanceof UpdateFunctionalProbeError && error.providerRefusal) {
-      return { kind: "refused", ...error.providerRefusal };
-    }
-    return { kind: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-  }
-}
-function describeCurrentReleaseOutcome(outcome) {
-  switch (outcome.kind) {
-    case "served":
-      return "the current release answered";
-    case "refused":
-      return `the current release got a different refusal (${outcome.reason})`;
-    case "sandbox-unavailable":
-      return `the current release has the same unavailable sandbox (${outcome.reason})`;
-    case "model-unavailable":
-      return `the current release cannot serve that model either (${outcome.reason})`;
-    case "unavailable":
-      return `the current release could not be compared (${outcome.reason})`;
-  }
-}
-async function runUpdateFunctionalProbe(input) {
-  const command = input.config.agentCommand ?? input.config.agentBinary;
-  const harnessLabel = harnessIdentityLabel({
-    kind: input.config.agentKind,
-    command
-  });
-  const harness = input.config.agentKind ?? command;
-  if (input.config.modelUnavailable) {
-    const detail = input.config.modelUnavailable.detail;
-    if (!input.compareWithCurrentRelease) {
-      throw new UpdateFunctionalProbeError("model-unavailable", detail);
-    }
-    const current = await input.compareWithCurrentRelease({
-      kind: "model-unavailable",
-      reason: detail
-    });
-    if (current.kind !== "model-unavailable" && current.kind !== "unavailable") {
-      throw new UpdateFunctionalProbeError("model-unavailable", `${detail}; ${describeCurrentReleaseOutcome(current)}`);
-    }
-    console.warn("[body] update probe: the configured model is unavailable to this release and the current release alike; that is the account catalog, not the bundle, so the probe passes without a model answer");
-    return {
-      harness,
-      sandboxed: false,
-      sessionStarted: false,
-      turnCompleted: false,
-      nativeTools: [],
-      modelAnswer: "unavailable",
-      modelAnswerReason: `${detail} (the current release cannot serve that model either)`
-    };
-  }
-  if (input.sandboxRequired && !input.config.bwrapPath) {
-    const detail = input.sandboxUnavailableDetail ?? "the configured bubblewrap boundary did not pass its startup self-test";
-    if (!input.compareWithCurrentRelease) {
-      throw new UpdateFunctionalProbeError("sandbox-unavailable", detail);
-    }
-    const current = await input.compareWithCurrentRelease({
-      kind: "sandbox-unavailable",
-      reason: detail
-    });
-    if (current.kind !== "sandbox-unavailable") {
-      throw new UpdateFunctionalProbeError("sandbox-unavailable", `${detail}; ${describeCurrentReleaseOutcome(current)}`);
-    }
-    console.warn("[body] update probe: the sandbox is unavailable to this release and the current release alike; preserving fail-closed sandboxing and accepting the bundle as inconclusive");
-    return {
-      harness,
-      sandboxed: false,
-      sessionStarted: false,
-      turnCompleted: false,
-      nativeTools: [],
-      modelAnswer: "unavailable",
-      modelAnswerReason: `${detail} (the current release has the same host sandbox failure)`
-    };
-  }
-  const root = input.probeRoot ?? resolve34(input.runtimeDir, "update-functional-probe");
-  const cwd = resolve34(root, "checkout");
-  const homeRoot = resolve34(root, "agent-home");
-  await rm12(root, { recursive: true, force: true });
-  await mkdir24(cwd, { recursive: true, mode: 448 });
-  let client;
-  try {
-    const agentEnv = {
-      ...input.config.agentEnv,
-      ...await prepareRoomAgentHome({
-        root: homeRoot,
-        operatorHome: input.config.operatorHome ?? homedir16(),
-        sharedSkills: input.config.sharedSkills ?? [],
-        ...input.config.agentKind ? { agentKind: input.config.agentKind } : {},
-        skillReleaseId: input.releaseId,
-        failClosed: true,
-        ...openRouterRoutingInput({ ...input.config, openRouterRoutingCacheDir: openRouterRoutingCacheDir(input.runtimeDir) }, input.config.modelSelection)
-      })
-    };
-    const selectedAgent = {
-      kind: input.config.agentKind,
-      command,
-      args: input.config.agentArgs ?? []
-    };
-    let spawnCommand = {
-      command,
-      args: agentArgsWithModelSelection(selectedAgent, input.config.modelSelection)
-    };
-    let modelAnswer = {};
-    let turnCompleted = true;
-    if (input.config.bwrapPath) {
-      const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-      const operatorHome = input.config.operatorHome ?? homedir16();
-      const homeStateDirs = harnessHomeStateDirs(harnessLabel, agentEnv.HOME ?? operatorHome);
-      await Promise.all(homeStateDirs.map((dir) => mkdir24(dir, { recursive: true })));
-      spawnCommand = wrapAgentCommand({
-        bwrapPath: input.config.bwrapPath,
-        spec: {
-          mode: "readonly",
-          cwd,
-          harnessStateDirs: stateDirs,
-          harnessHomeStateDirs: homeStateDirs,
-          maskPaths: credentialMaskPaths(input.config.sandboxMaskPaths, operatorHome),
-          ...tmpDir ? { tmpDir } : {}
-        },
-        command,
-        args: spawnCommand.args
-      });
-    }
-    client = new AcpClient({
-      agentCommand: spawnCommand.command,
-      agentArgs: spawnCommand.args,
-      agentLabel: harnessLabel,
-      agentEnv,
-      agentCwd: cwd,
-      autoApprovePermissions: true
-    });
-    const sessionTimeoutMs = input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_TIMEOUT_MS;
-    const sessionOpenTimeoutMs = input.sessionOpenTimeoutMs ?? input.sessionTimeoutMs ?? UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS;
-    const openSessionAndPrompt = async () => {
-      const opened = await client.sessionNew({
-        cwd,
-        mcpServers: [],
-        systemPrompt: "This is Beeline update validation. Answer only READY.",
-        mode: "readonly",
-        timeoutMs: sessionOpenTimeoutMs
-      });
-      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 { sessionId, served } = await openSessionAndPrompt();
-        if (served.agentText.trim()) {
-          modelAnswer = { modelAnswer: "served" };
-        } else {
-          const explained = await explainEmptyAgentTurn({
-            agentLabel: harnessLabel,
-            agentEnv,
-            sessionId,
-            result: served
-          });
-          const modelSide = isAccountOrProviderRefusal(explained.record) || explained.record?.kind === "empty";
-          if (!modelSide) {
-            const refusal = explained.record?.kind === "error" && explained.record.status !== void 0 ? { status: explained.record.status, reason: explained.record.reason } : void 0;
-            const detail = `the harness completed a session/prompt without an agent answer: ${explained.reason}`;
-            if (!refusal || !input.compareWithCurrentRelease) {
-              throw new UpdateFunctionalProbeError("turn-failed", detail, {
-                ...refusal ? { providerRefusal: refusal } : {}
-              });
-            }
-            const current = await input.compareWithCurrentRelease({
-              kind: "provider-refusal",
-              reason: refusal.reason,
-              refusal
-            });
-            if (current.kind !== "refused" || current.status !== refusal.status) {
-              throw new UpdateFunctionalProbeError("turn-failed", `${detail}; ${describeCurrentReleaseOutcome(current)}`, { providerRefusal: refusal });
-            }
-            const reason = `${explained.reason} (the current release gets the same ${refusal.status})`;
-            console.warn(`[body] update probe: the provider refused this release and the current release alike (${refusal.reason}); that refusal is not this bundle's doing, so the probe passes as inconclusive`);
-            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: reason };
-          } else {
-            console.warn(`[body] update probe: the bundle reached the model boundary but the model answered nothing (${explained.reason}); that is the model's own answer on any release, so the probe passes without one`);
-            modelAnswer = { modelAnswer: "unavailable", modelAnswerReason: explained.reason };
-          }
-        }
-      } catch (initialError) {
-        if (initialError instanceof UpdateFunctionalProbeError)
-          throw initialError;
-        let error = initialError;
-        let detail = error instanceof Error ? error.message : String(error);
-        let failure2 = classifyAcpTurnFailure(error);
-        if (failure2) {
-          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(failure2, retryFailure)) {
-              throw new UpdateFunctionalProbeError("turn-failed", retryDetail, {
-                cause: retryError
-              });
-            }
-            error = retryError;
-            detail = retryDetail;
-            failure2 = retryFailure;
-          }
-        }
-        if (error === void 0) {
-        } else if (!failure2 || !input.compareWithCurrentRelease) {
-          throw new UpdateFunctionalProbeError("turn-failed", detail, { cause: error });
-        } else {
-          const current = await input.compareWithCurrentRelease({
-            kind: "acp-turn-failure",
-            reason: detail,
-            failure: failure2
-          });
-          const currentFailure = current.kind === "unavailable" ? classifyAcpTurnFailure(current.reason) : void 0;
-          if (!currentFailure || !sameAcpTurnFailure(failure2, 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)`
-          };
-        }
-      }
-    } catch (error) {
-      if (error instanceof UpdateFunctionalProbeError)
-        throw error;
-      throw new UpdateFunctionalProbeError("session-start-failed", error instanceof Error ? error.message : String(error), { cause: error });
-    }
-    return {
-      harness,
-      sandboxed: Boolean(input.config.bwrapPath),
-      sessionStarted: true,
-      turnCompleted,
-      nativeTools: [],
-      ...modelAnswer
-    };
-  } finally {
-    await client?.stop().catch(() => void 0);
-    await rm12(root, { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-
 // apps/body/dist/current-release-probe.js
 import { spawn as spawn13 } from "node:child_process";
 import { dirname as dirname25, join as join15 } from "node:path";
@@ -44049,18 +44116,20 @@ async function runStoredDaemon(pathOrPointer) {
       update,
       quiesceIfIdle: () => core.quiesceForUpdateIfIdle(),
       activeTurnCount: () => core.activeTurnCount(),
-      restart: async ({ desiredRelease, drainDeadlineAt }, mode) => {
-        if (mode === "forced")
-          await core.prepareForForcedUpdateRestart();
+      restart: async ({ desiredRelease, drainDeadlineAt }) => {
         core.setDrainDeadlineAt(drainDeadlineAt);
-        stoppingStatus = `update pending, converging; loaded_release=${loadedRelease ?? "unknown"}; desired_release=${desiredRelease}; ${mode === "forced" ? "active work cancelled at the drain deadline" : "active work drained"}; intake quiesced; exit_deadline=${new Date(drainDeadlineAt).toISOString()}`;
+        stoppingStatus = `update pending, converging; loaded_release=${loadedRelease ?? "unknown"}; desired_release=${desiredRelease}; active work drained; intake quiesced`;
         await notifier.stopping(stoppingStatus);
         controller.abort();
       },
-      waiting: async ({ desiredRelease, drainDeadlineAt }) => {
-        await notifier.progress(`loaded_release=${loadedRelease ?? "unknown"}; update ready; active agent work is still running; handoff deferred; desired_release=${desiredRelease}; exit_deadline=${new Date(drainDeadlineAt).toISOString()}`);
+      waiting: async ({ desiredRelease }) => {
+        await notifier.progress(`loaded_release=${loadedRelease ?? "unknown"}; update ready; active agent work is still running; handoff deferred; desired_release=${desiredRelease}`);
       }
     }) : void 0;
+    daemonApi.setHelperReleaseListener(({ version, sha }) => {
+      update?.notifyReleaseAvailable(`${version}:${sha}`);
+      void updateDrain?.tick();
+    });
     const result = await core.run({
       signal: controller.signal,
       onEstablished: async () => {
@@ -44095,10 +44164,18 @@ async function runStoredDaemon(pathOrPointer) {
             successorRolledBack = gate.rolledBack;
             throw gate.error;
           }
-          functionalProof = gate.proof;
+          if (gate.kind === "agent-unavailable") {
+            if (!config.modelUnavailable) {
+              config.modelUnavailable = modelUnavailableState(config.modelSelection ?? runtime.modelSelection ?? {}, gate.error.cause ?? gate.error);
+            }
+            console.warn(`[thin-core] new release retained; this agent's selected model is unavailable: ${gate.error.message}`);
+          } else {
+            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})` : ""));
+          if (functionalProof)
+            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);
         await writeDaemonReleaseStatus(runtimeDir, runtime.agent.publicKey, loadedReleaseIdentity);