usebeeline 0.1.33 → 0.1.35

package/dist/usebeeline.mjs

@@ -212,8 +212,8 @@ async function runSquireBrokerLink(options) {
   const pending = /* @__PURE__ */ new Map();
   const queued = [];
   let resolveDone;
-  const done = new Promise((resolve52) => {
-    resolveDone = resolve52;
+  const done = new Promise((resolve53) => {
+    resolveDone = resolve53;
   });
   const failResponse = (id) => `${JSON.stringify({
     jsonrpc: "2.0",
@@ -4891,12 +4891,24 @@ async function notify(fields) {
 async function extendSystemdStartTimeout(ms) {
   await notify([`EXTEND_TIMEOUT_USEC=${Math.max(0, Math.round(ms)) * 1e3}`]).catch(() => void 0);
 }
-function startLocalWatchdog(notifier, status, intervalMs = 6e4, env = process.env) {
+function startLocalWatchdog(notifier, status, workLoopProgress, intervalMs = 6e4, env = process.env) {
   if (!env.WATCHDOG_USEC)
     return () => void 0;
-  const timer = setInterval(() => void notifier.progress(status()).catch((error) => console.error("[thin-core] watchdog notification failed:", error)), intervalMs);
+  let pending = false;
+  let stopped = false;
+  const timer = setInterval(() => {
+    if (pending || stopped)
+      return;
+    pending = true;
+    void workLoopProgress().then((progressed) => stopped || progressed === false ? void 0 : notifier.progress(status(), true)).catch((error) => console.error("[thin-core] watchdog notification failed:", error)).finally(() => {
+      pending = false;
+    });
+  }, intervalMs);
   timer.unref?.();
-  return () => clearInterval(timer);
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
 }
 var execFileAsync, DELIBERATE_REMOVAL_EXIT_STATUS, DAEMON_DISTRESS_EXIT_STATUS, UNKNOWN_AGENT_EXIT_STATUS, SYSTEMD_UNIT_NAME, SYSTEMD_HELPER_UNIT_NAME, NO_AGENTS_EXIT_STATUS, SYSTEMD_COMMAND_TIMEOUT_MS, SYSTEMD_RESTART_WAIT_MS, AGENT_SERVICE, runSystemctl, SystemdNotifier;
 var init_systemd = __esm({
@@ -4924,8 +4936,8 @@ var init_systemd = __esm({
       async ready(status) {
         await notify(["--ready", `--status=${status}`]);
       }
-      async progress(status) {
-        await notify(["WATCHDOG=1", `STATUS=${status}`]);
+      async progress(status, watchdog = false) {
+        await notify([...watchdog ? ["WATCHDOG=1"] : [], `STATUS=${status}`]);
       }
       async stopping(status) {
         await notify(["STOPPING=1", `STATUS=${status}`]);
@@ -5804,14 +5816,13 @@ var init_self_update = __esm({
       fetchImpl;
       log;
       stageOnly;
-      nextCheckAllowedAt = 0;
       disposed = false;
       applying = false;
       deferredBusyNotice = false;
       lastVerdictLog = "";
       constructor(options) {
         const env = options.env ?? process.env;
-        const numberEnv2 = (name, fallback) => {
+        const numberEnv = (name, fallback) => {
           const raw = env[name];
           if (!raw)
             return fallback;
@@ -5820,8 +5831,7 @@ var init_self_update = __esm({
         };
         this.options = {
           layout: options.layout,
-          checkIntervalMs: options.checkIntervalMs ?? numberEnv2("BEELINE_UPDATE_INTERVAL_MS", 6 * 60 * 6e4),
-          idleTimeoutMs: options.idleTimeoutMs ?? numberEnv2("BEELINE_UPDATE_IDLE_TIMEOUT_MS", 30 * 6e4),
+          idleTimeoutMs: options.idleTimeoutMs ?? numberEnv("BEELINE_UPDATE_IDLE_TIMEOUT_MS", 30 * 6e4),
           idlePollMs: options.idlePollMs ?? 5e3,
           env,
           now: options.now ?? Date.now
@@ -5846,7 +5856,7 @@ var init_self_update = __esm({
           return;
         const now2 = this.options.now();
         const disabled = this.options.env.BEELINE_UPDATE_DISABLE === "1";
-        if (disabled || now2 < this.nextCheckAllowedAt)
+        if (disabled)
           return;
         this.applying = true;
         try {
@@ -13896,7 +13906,7 @@ function configureNetworkFamilyDefaults(network = net) {
 configureNetworkFamilyDefaults();
 
 // apps/body/dist/cli.js
-import { dirname as dirname32, resolve as resolve51 } from "node:path";
+import { dirname as dirname32, resolve as resolve52 } from "node:path";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -15336,7 +15346,7 @@ function parseCursorModelsOutput(output) {
   };
 }
 async function enumerateCursorModels(env = process.env) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve53) => {
     const child = spawn2("cursor-agent", ["models"], {
       env,
       stdio: ["ignore", "pipe", "ignore"]
@@ -15350,11 +15360,11 @@ async function enumerateCursorModels(env = process.env) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve52(void 0);
+      resolve53(void 0);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve52(code === 0 ? parseCursorModelsOutput(output) : void 0);
+      resolve53(code === 0 ? parseCursorModelsOutput(output) : void 0);
     });
   });
 }
@@ -15781,13 +15791,13 @@ var CursorAcpServer = class {
         consumeLine(line);
     });
     try {
-      const { code, signal } = await new Promise((resolve52) => {
+      const { code, signal } = await new Promise((resolve53) => {
         let settled = false;
         const finish = (exitCode, exitSignal) => {
           if (settled)
             return;
           settled = true;
-          resolve52({ code: exitCode, signal: exitSignal });
+          resolve53({ code: exitCode, signal: exitSignal });
         };
         child.once("error", (error) => {
           spawnError = error instanceof Error ? error.message : String(error);
@@ -15932,10 +15942,10 @@ function releaseSquireConnectSession(log2, owner = "") {
 function squireChromeProfileDir() {
   return process.env.TRUSTY_SQUIRE_PROFILE_DIR ?? squireHostPaths(homedir2()).profileDir;
 }
-var defaultShellRunner = (command, args) => new Promise((resolve52) => {
+var defaultShellRunner = (command, args) => new Promise((resolve53) => {
   execFile(command, [...args], { timeout: 12e4, maxBuffer: 4 * 1024 * 1024, encoding: "utf8" }, (error, stdout6, stderr) => {
     const code = error?.code;
-    resolve52({
+    resolve53({
       code: typeof code === "number" ? code : error ? 1 : 0,
       stdout: String(stdout6 ?? ""),
       stderr: String(stderr ?? "")
@@ -15960,7 +15970,7 @@ function killConnectTree(child) {
   }
   child.kill();
 }
-var defaultStreamedRunner = (command, args, env, owner = "") => new Promise((resolve52) => {
+var defaultStreamedRunner = (command, args, env, owner = "") => new Promise((resolve53) => {
   const child = spawn5(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
     env: env ?? squireConnectProcessEnv(),
@@ -15974,7 +15984,7 @@ var defaultStreamedRunner = (command, args, env, owner = "") => new Promise((res
   const safetyTimer = setTimeout(() => {
     if (!resolved) {
       resolved = true;
-      resolve52({ stdout: stdout6, stderr, pid: child.pid ?? void 0, report, abort: () => {
+      resolve53({ stdout: stdout6, stderr, pid: child.pid ?? void 0, report, abort: () => {
       } });
     }
     killConnectTree(child);
@@ -16009,7 +16019,7 @@ var defaultStreamedRunner = (command, args, env, owner = "") => new Promise((res
   const finish = (result) => {
     if (!resolved) {
       resolved = true;
-      resolve52(result);
+      resolve53(result);
     }
   };
   const settle = (result) => {
@@ -16501,13 +16511,13 @@ var StdioSquireMcpClient = class {
     const child = this.child;
     if (!child)
       return Promise.reject(new Error("Squire MCP session is not running"));
-    return new Promise((resolve52, reject) => {
+    return new Promise((resolve53, reject) => {
       const timeoutMs = method === "initialize" ? INITIALIZE_TIMEOUT_MS : CALL_TIMEOUT_MS;
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`${toolName2 ?? method} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve52, reject, timer });
+      this.pending.set(id, { resolve: resolve53, reject, timer });
       child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `);
     });
@@ -16798,9 +16808,9 @@ var SquireTaskRelay = class {
           response.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: error instanceof Error ? error.message : "Squire relay failed" }));
         }
       });
-      await new Promise((resolve52, reject) => {
+      await new Promise((resolve53, reject) => {
         server.once("error", reject);
-        server.listen(0, "127.0.0.1", resolve52);
+        server.listen(0, "127.0.0.1", resolve53);
       });
       this.server = server;
       const address = server.address();
@@ -17906,11 +17916,11 @@ var RegistryMcpHostBroker = class {
         })();
       });
     });
-    await new Promise((resolve52, reject) => {
+    await new Promise((resolve53, reject) => {
       this.server.once("error", reject);
       this.server.listen(this.socketPath, () => {
         this.server.off("error", reject);
-        resolve52();
+        resolve53();
       });
     });
     chmodSync(this.socketPath, 384);
@@ -17919,12 +17929,12 @@ var RegistryMcpHostBroker = class {
     const server = this.server;
     this.server = void 0;
     if (server)
-      await new Promise((resolve52) => server.close(() => resolve52()));
+      await new Promise((resolve53) => server.close(() => resolve53()));
     rmSync2(this.socketPath, { force: true });
   }
 };
 async function brokerRequest(socketPath, request) {
-  return new Promise((resolve52, reject) => {
+  return new Promise((resolve53, reject) => {
     const socket = createConnection3(socketPath);
     let output = "";
     socket.setEncoding("utf8");
@@ -17941,7 +17951,7 @@ async function brokerRequest(socketPath, request) {
           throw new Error(parsed.error);
         if (!Array.isArray(parsed.messages) || !parsed.messages.every((entry) => typeof entry === "string"))
           throw new Error("Registry MCP broker returned an invalid response");
-        resolve52(parsed.messages);
+        resolve53(parsed.messages);
       } catch (error) {
         reject(error);
       }
@@ -18740,6 +18750,7 @@ var AgentChannel = class {
   #registered = false;
   /** A register frame is in flight on the current socket. */
   #pending = false;
+  #refused = false;
   #registeredAt;
   #failures = 0;
   #retry;
@@ -18764,7 +18775,7 @@ var AgentChannel = class {
     return () => this.#openListeners.delete(listener);
   }
   start() {
-    if (this.#wanted)
+    if (this.#wanted || this.#refused)
       return;
     this.#wanted = true;
     this.machine.want(this);
@@ -18797,7 +18808,7 @@ var AgentChannel = class {
   }
   /** The socket opened: ask the server to take this agent. */
   register() {
-    if (!this.#wanted || this.#registered || this.#pending)
+    if (!this.#wanted || this.#registered || this.#pending || this.#refused)
       return;
     clearTimeout(this.#retry);
     this.#retry = void 0;
@@ -18819,6 +18830,7 @@ var AgentChannel = class {
       this.#registeredAt = Date.now();
       this.#registrations += 1;
       this.handlers.onOpen();
+      this.machine.registered();
       for (const listener of [...this.#openListeners]) {
         try {
           listener();
@@ -18829,11 +18841,20 @@ var AgentChannel = class {
       return;
     }
     if (event.type === "register-refused") {
+      if (this.#refused)
+        return;
       this.#pending = false;
       const code = typeof event.code === "string" ? event.code : "refused";
       console.warn(`[machine-link] server refused agent ${this.agentId}: ${code}`);
+      this.#refused = ["daemon_token_required", "agent_removed", "too_many_agents"].includes(code);
       this.handlers.onRefused?.(code);
-      this.#retryLater();
+      if (this.#refused) {
+        this.#wanted = false;
+        clearTimeout(this.#retry);
+        this.#retry = void 0;
+        this.machine.unwant(this);
+      } else
+        this.#retryLater();
       return;
     }
     if (event.type === "unregistered") {
@@ -18890,6 +18911,8 @@ var MachineLink = class {
   link;
   #channels = /* @__PURE__ */ new Map();
   #identity = { releaseVersion: "v0.0.0" };
+  #reconciledOnSocket = false;
+  #pendingRelease;
   random;
   constructor(options) {
     this.options = options;
@@ -18899,11 +18922,15 @@ var MachineLink = class {
       protocols: () => [MACHINE_SOCKET_PROTOCOL],
       factory: options.factory ?? ((url, protocols, socketOptions) => new wrapper_default(url, protocols, socketOptions)),
       onOpen: () => {
+        this.#reconciledOnSocket = false;
+        this.#pendingRelease = void 0;
         for (const channel of this.#channels.values())
           channel.register();
       },
       onMessage: (data) => this.#message(data),
       onClose: () => {
+        this.#reconciledOnSocket = false;
+        this.#pendingRelease = void 0;
         for (const channel of this.#channels.values())
           channel.socketClosed();
       },
@@ -18921,6 +18948,18 @@ var MachineLink = class {
       ...identity.sourceSha ? { sourceSha: identity.sourceSha } : {}
     };
   }
+  /** The first accepted registration follows the server's cached release frame. */
+  registered() {
+    if (this.#reconciledOnSocket)
+      return;
+    this.#reconciledOnSocket = true;
+    this.options.onRegistered?.();
+    if (this.#pendingRelease) {
+      const release = this.#pendingRelease;
+      this.#pendingRelease = void 0;
+      this.#broadcast(release);
+    }
+  }
   /** A later channel for the same agent (an in-process restart) replaces the earlier one. */
   attach(agentId, handlers) {
     return new AgentChannel(this, agentId, handlers);
@@ -18974,13 +19013,19 @@ var MachineLink = class {
       return;
     }
     if (event.type === "helper-release") {
-      for (const channel of this.#channels.values())
-        channel.broadcast(event);
+      if (!this.#reconciledOnSocket)
+        this.#pendingRelease = event;
+      else
+        this.#broadcast(event);
       return;
     }
     if (event.type !== "hello" && event.type !== "force-update")
       this.#logUnknown(event.type);
   }
+  #broadcast(event) {
+    for (const channel of this.#channels.values())
+      channel.broadcast(event);
+  }
 };
 
 // apps/body/dist/agent-sign-in.js
@@ -19438,7 +19483,7 @@ var AgentSignIn = class {
     };
     for (const name of ISOLATION_VARIABLES)
       delete env[name];
-    return new Promise((resolve52, reject) => {
+    return new Promise((resolve53, reject) => {
       let output = "";
       let answered = false;
       let child;
@@ -19479,7 +19524,7 @@ var AgentSignIn = class {
           return;
         answered = true;
         clearTimeout(linkTimer);
-        resolve52(link2);
+        resolve53(link2);
       };
       child.stdout?.on("data", read2);
       child.stderr?.on("data", read2);
@@ -28367,19 +28412,19 @@ function wellKnownExecutableDirs(env = process.env) {
   return [...versioned, resolve7(home, ".local", "bin"), "/usr/local/bin", "/opt/homebrew/bin"];
 }
 function augmentedSearchDirectories(env = process.env) {
-  const directories = [];
+  const directories2 = [];
   const pushAll = (paths) => {
     for (const directory of paths) {
-      if (directory && !directories.includes(directory))
-        directories.push(directory);
+      if (directory && !directories2.includes(directory))
+        directories2.push(directory);
     }
   };
   pushAll((env.PATH ?? "").split(delimiter));
   if (env.BEELINE_HARNESS_PATH_AUGMENT === "0")
-    return directories;
+    return directories2;
   pushAll(wellKnownExecutableDirs(env));
   pushAll((env.BEELINE_LAUNCHER_PATH ?? "").split(delimiter));
-  return directories;
+  return directories2;
 }
 function describeExecutableSearch(env = process.env) {
   return augmentedSearchDirectories(env).join(", ");
@@ -29328,13 +29373,13 @@ var RoomSupervisor = class {
    */
   retryDelay(failures, signal, since = this.#wakes) {
     const delay = this.delaysMs[failures - 1];
-    return new Promise((resolve52) => {
+    return new Promise((resolve53) => {
       let timer;
       const done = () => {
         clearTimeout(timer);
         this.#parked.delete(done);
         signal?.removeEventListener("abort", done);
-        resolve52();
+        resolve53();
       };
       this.#parked.add(done);
       signal?.addEventListener("abort", done, { once: true });
@@ -29519,12 +29564,12 @@ async function retryBeforeReady(work, options) {
           if (wait2 <= 0)
             break;
           await options.extendStartTimeout(wait2 + 15e3);
-          await new Promise((resolve52) => {
+          await new Promise((resolve53) => {
             const timer = setTimeout(done, wait2);
             function done() {
               clearTimeout(timer);
               options.signal?.removeEventListener("abort", done);
-              resolve52();
+              resolve53();
             }
             wake = done;
             options.signal?.addEventListener("abort", done, { once: true });
@@ -30549,7 +30594,6 @@ import { createHash as createHash8 } from "node:crypto";
 import { mkdir as mkdir13, rm as rm10, stat as stat8, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname13, resolve as resolve16 } from "node:path";
 var UPDATE_CONVERGENCE_SLO_MS = 10 * 6e4;
-var DEFAULT_UPDATE_INTERVAL_MS = 3e4;
 var UPDATE_DRAIN_DEADLINE_MS = 5 * 6e4;
 var MAX_HOST_RESTART_STAGGER_MS = 15e3;
 function managedRestartStaggerMs(agentId, desiredRelease, drainDeadlineAt, now2 = Date.now()) {
@@ -30559,7 +30603,6 @@ function managedRestartStaggerMs(agentId, desiredRelease, drainDeadlineAt, now2
 }
 var UPDATE_WORKER_DEADLINE_MS = UPDATE_CONVERGENCE_SLO_MS - 6e4;
 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 = resolve16(layout.releasesRoot, ".state", "install.lock");
@@ -30645,8 +30688,9 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   #now;
   #env;
   #runUpdateWorker;
+  #onWorkerSettled;
   #drainDeadlineMs;
-  #nextUpdateCheckAt;
+  #checkRequested = false;
   #updateCycleDeadlineAt;
   #worker;
   #requested = false;
@@ -30659,8 +30703,8 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     this.#now = options.now ?? Date.now;
     this.#env = options.env ?? process.env;
     this.#runUpdateWorker = options.runUpdateWorker ?? runManagedUpdateWorkerProcess;
+    this.#onWorkerSettled = options.onWorkerSettled;
     this.#drainDeadlineMs = options.drainDeadlineMs ?? UPDATE_DRAIN_DEADLINE_MS;
-    this.#nextUpdateCheckAt = this.#now() + numberEnv(this.#env, "BEELINE_UPDATE_INITIAL_DELAY_MS", DEFAULT_UPDATE_INITIAL_DELAY_MS);
   }
   static async create(layout, now2 = Date.now, options = {}) {
     const env = options.env ?? process.env;
@@ -30676,7 +30720,11 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     if (!releaseKey || this.#notifiedReleaseKey === releaseKey)
       return;
     this.#notifiedReleaseKey = releaseKey;
-    this.#nextUpdateCheckAt = 0;
+    this.#checkRequested = true;
+  }
+  /** A fresh socket covers notices missed while disconnected with one manifest read. */
+  reconcileOnConnect() {
+    this.#checkRequested = true;
   }
   /**
    * Return true once the active release differs from the serving release.
@@ -30691,50 +30739,49 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   async check() {
     if (this.#requested || !this.#loadedRelease)
       return this.#requested;
-    if (this.#stagedReleaseId)
-      return false;
     const desiredRelease = await activeReleaseId(this.#layout).catch(() => void 0);
     if (desiredRelease && desiredRelease !== this.#loadedRelease) {
       return this.#armRestart(desiredRelease);
     }
-    const state = await readUpdateState(this.#layout);
-    if (state.stagedReleaseId && state.stagedReleaseId !== this.#loadedRelease) {
-      const requestedAt = this.#now();
-      this.#stagedReleaseId = state.stagedReleaseId;
-      this.#restartRequest = {
-        loadedRelease: this.#loadedRelease,
-        desiredRelease: state.stagedReleaseId,
-        drainDeadlineAt: requestedAt + this.#drainDeadlineMs
-      };
-      console.log(`[thin-core] staged update ${state.stagedReleaseId} is waiting for active turns to drain`);
+    if (this.#worker)
       return false;
-    }
-    const now2 = this.#now();
-    if (this.#env.BEELINE_UPDATE_DISABLE === "1" || now2 < this.#nextUpdateCheckAt)
-      return false;
-    this.#nextUpdateCheckAt = now2 + numberEnv(this.#env, "BEELINE_UPDATE_INTERVAL_MS", DEFAULT_UPDATE_INTERVAL_MS);
-    if (!this.#worker) {
+    if (this.#env.BEELINE_UPDATE_DISABLE !== "1" && this.#checkRequested) {
+      this.#checkRequested = false;
+      const now2 = this.#now();
+      const notifiedReleaseKey = this.#notifiedReleaseKey;
       this.#updateCycleDeadlineAt = now2 + this.#drainDeadlineMs;
       this.#worker = withInstallLock(this.#layout, async () => {
         const current = await activeReleaseId(this.#layout).catch(() => void 0);
         if (current && current !== this.#loadedRelease)
           return;
-        const state2 = await readUpdateState(this.#layout);
-        const interval = numberEnv(this.#env, "BEELINE_UPDATE_INTERVAL_MS", DEFAULT_UPDATE_INTERVAL_MS);
-        if (state2.notifiedReleaseKey === this.#notifiedReleaseKey && state2.lastCheckAt !== void 0 && now2 - state2.lastCheckAt < interval)
-          return;
         await this.#runUpdateWorker();
-        if (this.#notifiedReleaseKey) {
+        if (notifiedReleaseKey) {
           await writeUpdateState(this.#layout, {
             ...await readUpdateState(this.#layout),
-            notifiedReleaseKey: this.#notifiedReleaseKey
+            notifiedReleaseKey
           });
         }
       }).catch((error) => {
         console.error(`[thin-core] update worker failed: ${error instanceof Error ? error.message : String(error)}`);
       }).finally(() => {
         this.#worker = void 0;
+        this.#onWorkerSettled?.();
       });
+      return false;
+    }
+    if (this.#stagedReleaseId)
+      return false;
+    const state = await readUpdateState(this.#layout);
+    if (state.stagedReleaseId && state.stagedReleaseId !== this.#loadedRelease) {
+      const requestedAt = this.#now();
+      this.#stagedReleaseId = state.stagedReleaseId;
+      this.#restartRequest = {
+        loadedRelease: this.#loadedRelease,
+        desiredRelease: state.stagedReleaseId,
+        drainDeadlineAt: requestedAt + this.#drainDeadlineMs
+      };
+      console.log(`[thin-core] staged update ${state.stagedReleaseId} is waiting for active turns to drain`);
+      return false;
     }
     return false;
   }
@@ -30823,6 +30870,7 @@ var ManagedUpdateDrain = class {
   #clearTimer;
   #waitLogTimer;
   #resolving;
+  #rerunRequested = false;
   #restarting = false;
   constructor(options) {
     this.#options = options;
@@ -30837,10 +30885,21 @@ var ManagedUpdateDrain = class {
   #resolve() {
     if (this.#restarting)
       return Promise.resolve("restarting");
-    if (this.#resolving)
+    if (this.#resolving) {
+      this.#rerunRequested = true;
       return this.#resolving;
+    }
     this.#resolving = this.#step().finally(() => {
       this.#resolving = void 0;
+      if (this.#rerunRequested) {
+        this.#rerunRequested = false;
+        void this.#resolve().catch((error) => {
+          if (this.#options.failed)
+            this.#options.failed(error);
+          else
+            this.#log(`[thin-core] update drain failed: ${String(error)}`);
+        });
+      }
     });
     return this.#resolving;
   }
@@ -30891,10 +30950,6 @@ function updateWaitMs(options, request) {
   const remaining = request.drainDeadlineAt - (options.now ?? Date.now)();
   return remaining > 0 ? remaining : UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS;
 }
-function numberEnv(env, name, fallback) {
-  const value = Number(env[name]);
-  return Number.isFinite(value) && value >= 0 ? value : fallback;
-}
 async function runManagedUpdateWorker() {
   const { beelineInstallLayout: beelineInstallLayout2 } = await Promise.resolve().then(() => (init_self_update(), self_update_exports));
   const layout = beelineInstallLayout2(process.env);
@@ -31014,8 +31069,8 @@ ${import_picocolors.default.dim("Usage:")}
   beeline update --force             Apply even when the comparison is indeterminate
   beeline update --manifest-url <u>  Override the published manifest URL
 
-The supervised daemon also checks automatically (every BEELINE_UPDATE_INTERVAL_MS,
-default 30s) with the same busy gate; BEELINE_UPDATE_DISABLE=1 turns the
+The supervised helper checks the manifest on connection and on release notices,
+then waits for a quiet gap to restart. BEELINE_UPDATE_DISABLE=1 turns the
 automatic path off. \`beeline update\` always works.
 `);
 }
@@ -31238,9 +31293,9 @@ async function runStartCommand(args, interactiveUi, dependencyOverrides = {}) {
 // apps/body/dist/connect-command.js
 import { spawn as spawn13 } from "node:child_process";
 import { createHash as createHash9, randomUUID as randomUUID9 } from "node:crypto";
-import { chmod as chmod6, mkdir as mkdir16, readFile as readFile20, unlink as unlink5, writeFile as writeFile13 } from "node:fs/promises";
+import { chmod as chmod6, mkdir as mkdir16, readFile as readFile21, unlink as unlink5, writeFile as writeFile13 } from "node:fs/promises";
 import { homedir as homedir12, hostname } from "node:os";
-import { dirname as dirname17, resolve as resolve22 } from "node:path";
+import { dirname as dirname17, resolve as resolve23 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
 // packages/api-contract/dist/phone-types.js
@@ -32307,11 +32362,11 @@ var AcpClient = class extends EventEmitter {
       }, timeoutMs);
     } catch (error) {
       if (launch && /EPIPE/.test(String(error)) && this.child?.exitCode === null) {
-        await new Promise((resolve52) => {
-          const timer = setTimeout(resolve52, 250);
+        await new Promise((resolve53) => {
+          const timer = setTimeout(resolve53, 250);
           this.child?.once("close", () => {
             clearTimeout(timer);
-            resolve52();
+            resolve53();
           });
         });
       }
@@ -32357,8 +32412,8 @@ ${String(error)}`);
       try {
         oomKilled = await Promise.race([
           this.oomKills.consume().catch(() => false),
-          new Promise((resolve52) => {
-            diagnosticTimer = setTimeout(() => resolve52(false), 100);
+          new Promise((resolve53) => {
+            diagnosticTimer = setTimeout(() => resolve53(false), 100);
           })
         ]);
       } finally {
@@ -32790,7 +32845,7 @@ ${String(error)}`);
     const current = this.activeRunIds.get(sessionId);
     if (current)
       return Promise.resolve(current);
-    return new Promise((resolve52, reject) => {
+    return new Promise((resolve53, reject) => {
       const onUpdate = (update) => {
         if (update.sessionId !== sessionId)
           return;
@@ -32798,7 +32853,7 @@ ${String(error)}`);
         if (!runId)
           return;
         cleanup();
-        resolve52(runId);
+        resolve53(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -32877,14 +32932,14 @@ ${String(error)}`);
     }
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve52, reject) => {
+    return new Promise((resolve53, reject) => {
       const timer = backstop ? void 0 : setTimeout(() => {
         this.pending.delete(id);
         reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, false, detail));
       }, timeoutMs);
       const sessionId = params?.sessionId;
       this.pending.set(id, {
-        resolve: resolve52,
+        resolve: resolve53,
         reject,
         timer,
         method,
@@ -33940,18 +33995,145 @@ async function pairDevice(grant, options = {}) {
 }
 
 // apps/body/dist/openrouter-routing.js
-import { mkdir as mkdir14, readFile as readFile18, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir14, readFile as readFile19, writeFile as writeFile11 } from "node:fs/promises";
+import { resolve as resolve21 } from "node:path";
+
+// apps/body/dist/openrouter-history.js
+import { createReadStream as createReadStream2 } from "node:fs";
+import { lstat as lstat5, readFile as readFile18, readdir as readdir6 } from "node:fs/promises";
 import { resolve as resolve20 } from "node:path";
+import { createInterface as createInterface6 } from "node:readline";
+var OPENROUTER_HISTORY_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+var OPENROUTER_GENERATION_URL = "https://openrouter.ai/api/v1/generation";
+function openRouterTraffic(observations) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const observation2 of observations) {
+    if (observation2.promptTokens <= 0)
+      continue;
+    const total = totals.get(observation2.provider) ?? { calls: 0, promptTokens: 0, cachedTokens: 0 };
+    total.calls++;
+    total.promptTokens += observation2.promptTokens;
+    total.cachedTokens += Math.min(observation2.promptTokens, Math.max(0, observation2.cachedTokens));
+    totals.set(observation2.provider, total);
+  }
+  return [...totals].map(([provider, total]) => ({ ...total, provider, cacheShare: total.cachedTokens / total.promptTokens }));
+}
+async function directories(root) {
+  return (await readdir6(root, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => resolve20(root, entry.name));
+}
+async function openRouterGenerationIds(roomsDir, model, now2) {
+  const ids = /* @__PURE__ */ new Map();
+  for (const room of await directories(roomsDir)) {
+    const ordinary = await Promise.all(["agent-home", "agent-home/pi", "agent-home/pi/sessions"].map(async (path) => {
+      const stat14 = await lstat5(resolve20(room, path)).catch(() => void 0);
+      return stat14?.isDirectory() && !stat14.isSymbolicLink();
+    }));
+    if (!ordinary.every(Boolean))
+      continue;
+    for (const project of await directories(resolve20(room, "agent-home/pi/sessions"))) {
+      const files = await readdir6(project, { withFileTypes: true }).catch(() => []);
+      for (const file of files) {
+        if (!file.isFile() || !file.name.endsWith(".jsonl"))
+          continue;
+        const stream = createReadStream2(resolve20(project, file.name), { encoding: "utf8" });
+        const lines = createInterface6({ input: stream, crlfDelay: Infinity });
+        try {
+          for await (const line of lines) {
+            try {
+              const { message } = JSON.parse(line);
+              if (message?.role !== "assistant" || message.model !== model || typeof message.responseId !== "string")
+                continue;
+              const timestamp = message.timestamp;
+              if (typeof timestamp === "number" && timestamp >= now2 - OPENROUTER_HISTORY_WINDOW_MS && timestamp <= now2) {
+                ids.set(message.responseId, timestamp);
+              }
+            } catch {
+            }
+          }
+        } catch {
+        } finally {
+          lines.close();
+          stream.destroy();
+        }
+      }
+    }
+  }
+  return ids;
+}
+function observation(value) {
+  if (!value || typeof value !== "object")
+    return void 0;
+  const row = value;
+  if (typeof row.id !== "string" || typeof row.provider !== "string" || typeof row.timestamp !== "number" || !Number.isFinite(row.timestamp) || typeof row.promptTokens !== "number" || !Number.isFinite(row.promptTokens) || row.promptTokens < 0 || typeof row.cachedTokens !== "number" || !Number.isFinite(row.cachedTokens) || row.cachedTokens < 0)
+    return void 0;
+  return {
+    id: row.id,
+    provider: row.provider,
+    timestamp: row.timestamp,
+    promptTokens: row.promptTokens,
+    cachedTokens: Math.min(row.cachedTokens, row.promptTokens),
+    ...typeof row.sessionId === "string" ? { sessionId: row.sessionId } : {}
+  };
+}
+async function readOpenRouterTraffic(input) {
+  const path = resolve20(input.cacheDir, `${input.model.replace(/[^A-Za-z0-9._-]+/g, "_")}.generations.json`);
+  let cached = [];
+  try {
+    const value = JSON.parse(await readFile18(path, "utf8"));
+    const record5 = value;
+    if (record5?.model === input.model && Array.isArray(record5.observations)) {
+      cached = record5.observations.map(observation).filter((row) => Boolean(row));
+    }
+  } catch {
+  }
+  const cutoff = input.now - OPENROUTER_HISTORY_WINDOW_MS;
+  const records = new Map(cached.filter((row) => row.timestamp >= cutoff && row.timestamp <= input.now).map((row) => [row.id, row]));
+  const ids = input.roomsDir ? await openRouterGenerationIds(input.roomsDir, input.model, input.now) : /* @__PURE__ */ new Map();
+  const missing = [...ids].filter(([id]) => !records.has(id));
+  let cursor3 = 0;
+  await Promise.all(Array.from({ length: Math.min(6, missing.length) }, async () => {
+    while (cursor3 < missing.length) {
+      const [id, timestamp] = missing[cursor3++];
+      try {
+        const response = await (input.fetchImpl ?? fetch)(`${OPENROUTER_GENERATION_URL}?id=${encodeURIComponent(id)}`, {
+          headers: { authorization: `Bearer ${input.apiKey}` },
+          signal: AbortSignal.timeout(input.timeoutMs ?? 1e4)
+        });
+        if (!response.ok)
+          continue;
+        const { data } = await response.json();
+        if (!data || data.id !== id)
+          continue;
+        const row = observation({
+          id,
+          timestamp,
+          provider: data.provider_name,
+          promptTokens: data.native_tokens_prompt,
+          cachedTokens: data.native_tokens_cached ?? 0,
+          sessionId: data.session_id
+        });
+        if (row)
+          records.set(id, row);
+      } catch {
+      }
+    }
+  }));
+  await writePrivateFileAtomically(path, `${JSON.stringify({ model: input.model, observations: [...records.values()] })}
+`).catch(() => void 0);
+  return openRouterTraffic([...records.values()]);
+}
+
+// apps/body/dist/openrouter-routing.js
 var OPENROUTER_ENDPOINTS_BASE_URL = "https://openrouter.ai/api/v1/models";
 var OPENROUTER_COMPLETIONS_URL = "https://openrouter.ai/api/v1/chat/completions";
 var OPENROUTER_ROUTING_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var OPENROUTER_ROUTING_FETCH_TIMEOUT_MS = 1e4;
-var OPENROUTER_PROBE_CACHE_TTL_MS = 6 * 60 * 60 * 1e3;
 var OPENROUTER_PROBE_MAX_CANDIDATES = 6;
 var OPENROUTER_PROBE_TIMEOUT_MS = 2e4;
 var OPENROUTER_UPTIME_BAR = 98;
 var OPENROUTER_UPTIME_BAR_RELAXED = 95;
 var OPENROUTER_MIN_PROVIDERS = 2;
+var ROUTING_POLICY = "cache-sticky-v1";
 var OPENROUTER_MAX_OUTPUT_TOKENS = 32768;
 var OPENROUTER_FALLBACK_PROVIDERS = ["deepinfra", "novita"];
 function openRouterModelId(model, env = {}) {
@@ -33983,12 +34165,19 @@ function parseOpenRouterEndpoints(payload) {
     const contextLength = typeof endpoint2.context_length === "number" ? endpoint2.context_length : 0;
     const maxCompletionTokens = typeof endpoint2.max_completion_tokens === "number" ? endpoint2.max_completion_tokens : 0;
     const supported = Array.isArray(endpoint2.supported_parameters) ? endpoint2.supported_parameters : [];
+    const pricing = endpoint2.pricing && typeof endpoint2.pricing === "object" ? endpoint2.pricing : {};
+    const promptPrice = tokenPrice(pricing.prompt);
+    const cacheReadPrice = tokenPrice(pricing.input_cache_read);
     endpoints.push({
       provider,
       uptime,
       contextLength,
       maxCompletionTokens,
-      tools: supported.includes("tools")
+      tools: supported.includes("tools"),
+      ...typeof endpoint2.provider_name === "string" ? { providerName: endpoint2.provider_name } : {},
+      ...promptPrice === void 0 ? {} : { promptPrice },
+      ...cacheReadPrice === void 0 ? {} : { cacheReadPrice },
+      discountedCacheRead: promptPrice !== void 0 && cacheReadPrice !== void 0 && cacheReadPrice < promptPrice
     });
   }
   const architecture = record5.architecture && typeof record5.architecture === "object" ? record5.architecture : {};
@@ -33999,6 +34188,30 @@ function parseOpenRouterEndpoints(payload) {
     inputModalities: modalities?.length ? modalities : void 0
   };
 }
+function rankOpenRouterProviders(endpoints, contextLength, traffic, answered) {
+  const shares2 = traffic.filter((row) => row.promptTokens > 0).map((row) => row.cacheShare).sort((a2, b) => a2 - b);
+  const middle = Math.floor(shares2.length / 2);
+  const medianShare = shares2.length ? (shares2[middle] + shares2[Math.floor((shares2.length - 1) / 2)]) / 2 : 0;
+  const normalize2 = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const ranked = /* @__PURE__ */ new Map();
+  for (const endpoint2 of endpoints) {
+    if (!endpoint2.tools || endpoint2.uptime < OPENROUTER_UPTIME_BAR_RELAXED || contextLength !== void 0 && endpoint2.contextLength < contextLength || !answered.includes(endpoint2.provider) || endpoint2.promptPrice === void 0)
+      continue;
+    const measured = traffic.find((row2) => normalize2(row2.provider) === normalize2(endpoint2.providerName ?? endpoint2.provider));
+    const cacheShare = measured?.cacheShare ?? medianShare;
+    const effectiveInputPrice = endpoint2.promptPrice * (1 - cacheShare) + (endpoint2.cacheReadPrice ?? endpoint2.promptPrice) * cacheShare;
+    const row = { provider: endpoint2.provider, cacheShare, measuredCalls: measured?.calls ?? 0, effectiveInputPrice };
+    if (!ranked.has(row.provider) || effectiveInputPrice < ranked.get(row.provider).effectiveInputPrice)
+      ranked.set(row.provider, row);
+  }
+  return [...ranked.values()].sort((a2, b) => a2.effectiveInputPrice - b.effectiveInputPrice || a2.provider.localeCompare(b.provider));
+}
+function tokenPrice(value) {
+  if (typeof value !== "number" && (typeof value !== "string" || !value.trim()))
+    return void 0;
+  const price = Number(value);
+  return Number.isFinite(price) && price >= 0 ? price : void 0;
+}
 function piInputModalities(modalities) {
   if (!modalities)
     return void 0;
@@ -34028,12 +34241,14 @@ function advertisedContextLength(endpoints) {
 }
 function selectReliableOpenRouterProviders(endpoints, contextLength) {
   const eligible = endpoints.filter((endpoint2) => endpoint2.tools && (contextLength === void 0 || endpoint2.contextLength >= contextLength));
+  const caching = eligible.filter((endpoint2) => endpoint2.discountedCacheRead && endpoint2.uptime >= OPENROUTER_UPTIME_BAR_RELAXED);
+  const candidates = caching.length ? caching : eligible;
   const atBar = (bar) => {
     const seen = /* @__PURE__ */ new Set();
-    return eligible.filter((endpoint2) => endpoint2.uptime >= bar).sort((left, right) => right.uptime - left.uptime).map((endpoint2) => endpoint2.provider).filter((provider) => seen.has(provider) ? false : (seen.add(provider), true));
+    return candidates.filter((endpoint2) => endpoint2.uptime >= bar).sort((left, right) => right.uptime - left.uptime).map((endpoint2) => endpoint2.provider).filter((provider) => seen.has(provider) ? false : (seen.add(provider), true));
   };
   const strict = atBar(OPENROUTER_UPTIME_BAR);
-  if (strict.length >= OPENROUTER_MIN_PROVIDERS) {
+  if (strict.length >= OPENROUTER_MIN_PROVIDERS && (caching.length === 0 || caching.every((endpoint2) => endpoint2.uptime >= OPENROUTER_UPTIME_BAR))) {
     return { providers: strict, bar: OPENROUTER_UPTIME_BAR, contextLength };
   }
   const relaxed = atBar(OPENROUTER_UPTIME_BAR_RELAXED);
@@ -34055,20 +34270,24 @@ function openRouterModelLimits(endpoints, providers) {
 function openRouterRoutingFor(providers, allowFallbacks = true) {
   return {
     only: [...providers],
-    order: [...providers],
+    // provider.order disables OpenRouter's session stickiness. Pi already
+    // sends its session id; OpenRouter keeps the successful cache provider
+    // and falls back on failure, within `only`, without bouncing to the old
+    // first choice on every request. A recovery override remains explicit.
+    ...allowFallbacks ? {} : { order: [...providers] },
     allow_fallbacks: allowFallbacks,
     require_parameters: false
   };
 }
 function openRouterRoutingCacheDir(runtimeDir) {
-  return resolve20(runtimeDir, "openrouter-routing");
+  return resolve21(runtimeDir, "openrouter-routing");
 }
 function cachePath(cacheDir, model) {
-  return resolve20(cacheDir, `${model.replace(/[^A-Za-z0-9._-]+/g, "_")}.json`);
+  return resolve21(cacheDir, `${model.replace(/[^A-Za-z0-9._-]+/g, "_")}.json`);
 }
 async function readCache(cacheDir, model) {
   try {
-    const parsed = JSON.parse(await readFile18(cachePath(cacheDir, model), "utf8"));
+    const parsed = JSON.parse(await readFile19(cachePath(cacheDir, model), "utf8"));
     if (!parsed || typeof parsed !== "object")
       return void 0;
     const cached = parsed;
@@ -34078,6 +34297,7 @@ async function readCache(cacheDir, model) {
     const input = Array.isArray(cached.input) ? cached.input.filter((value) => value === "text" || value === "image") : cached.input === null ? null : void 0;
     const limits = cached.limits === null ? null : cachedLimits(cached.limits);
     return {
+      policy: typeof cached.policy === "string" ? cached.policy : void 0,
       model,
       fetchedAt: cached.fetchedAt,
       providers: cached.providers,
@@ -34106,41 +34326,6 @@ async function writeCache(cacheDir, value) {
     mode: 384
   });
 }
-function probeCachePath(cacheDir, model) {
-  return resolve20(cacheDir, `${model.replace(/[^A-Za-z0-9._-]+/g, "_")}.probe.json`);
-}
-async function readProbeCache(cacheDir, model) {
-  try {
-    const parsed = JSON.parse(await readFile18(probeCachePath(cacheDir, model), "utf8"));
-    if (!parsed || typeof parsed !== "object")
-      return void 0;
-    const cached = parsed;
-    if (cached.model !== model || typeof cached.fetchedAt !== "number")
-      return void 0;
-    if (!Array.isArray(cached.answered))
-      return void 0;
-    const answered = [];
-    for (const entry of cached.answered) {
-      if (!entry || typeof entry !== "object")
-        return void 0;
-      const { provider, latencyMs } = entry;
-      if (typeof provider !== "string" || !provider || typeof latencyMs !== "number") {
-        return void 0;
-      }
-      answered.push({ provider, latencyMs });
-    }
-    return { model, fetchedAt: cached.fetchedAt, answered };
-  } catch {
-    return void 0;
-  }
-}
-async function writeProbeCache(cacheDir, value) {
-  await mkdir14(cacheDir, { recursive: true, mode: 448 });
-  await writeFile11(probeCachePath(cacheDir, value.model), `${JSON.stringify(value, null, 2)}
-`, {
-    mode: 384
-  });
-}
 var PROBE_TOOL = {
   type: "function",
   function: {
@@ -34226,7 +34411,7 @@ async function probeOpenRouterProviders(input) {
 function decision(model, providers, bar, source, note, allowFallbacks = true, input, limits) {
   const criteria = bar === null ? "fallback pair" : `uptime \u2265${bar}%, tools`;
   const suffix = [
-    bar === OPENROUTER_UPTIME_BAR_RELAXED ? "bar lowered: fewer than 2 providers at 98%" : "",
+    bar === OPENROUTER_UPTIME_BAR_RELAXED && !note?.startsWith("daily") ? "bar lowered: reliability fallback or cache continuity" : "",
     source === "cache" ? "cached" : "",
     source === "stale-cache" ? "stale cache" : "",
     note ?? ""
@@ -34245,7 +34430,7 @@ function decision(model, providers, bar, source, note, allowFallbacks = true, in
 async function resolveUptimeRouting(input) {
   const now2 = input.now ?? Date.now;
   const cached = await readCache(input.cacheDir, input.model);
-  if (cached?.input !== void 0 && cached.limits !== void 0 && now2() - cached.fetchedAt < OPENROUTER_ROUTING_CACHE_TTL_MS) {
+  if (cached?.policy === ROUTING_POLICY && cached?.input !== void 0 && cached.limits !== void 0 && now2() - cached.fetchedAt < OPENROUTER_ROUTING_CACHE_TTL_MS) {
     return decision(input.model, cached.providers, cached.bar, "cache", void 0, true, cached.input ?? void 0, cached.limits ?? void 0);
   }
   let failure;
@@ -34264,8 +34449,16 @@ async function resolveUptimeRouting(input) {
     if (selected.providers.length === 0) {
       return decision(input.model, OPENROUTER_FALLBACK_PROVIDERS, null, "fallback", "no provider met the bar", true, modelInput);
     }
+    if (cached?.policy === ROUTING_POLICY) {
+      const retained = cached.providers.filter((provider) => selected.providers.includes(provider));
+      selected.providers = [
+        ...retained,
+        ...selected.providers.filter((provider) => !retained.includes(provider))
+      ];
+    }
     const limits = openRouterModelLimits(endpoints, selected.providers);
     await writeCache(input.cacheDir, {
+      policy: ROUTING_POLICY,
       model: input.model,
       fetchedAt: now2(),
       providers: selected.providers,
@@ -34283,62 +34476,106 @@ async function resolveUptimeRouting(input) {
   }
   return decision(input.model, OPENROUTER_FALLBACK_PROVIDERS, null, "fallback", `api unreachable: ${failure}`);
 }
-var inFlightProbes = /* @__PURE__ */ new Map();
-function answeringProviders(probe, candidates) {
-  return probe.answered.map((entry) => entry.provider).filter((provider) => candidates.includes(provider));
+function dailyCachePath(input) {
+  return resolve21(input.cacheDir, `${input.model.replace(/[^A-Za-z0-9._-]+/g, "_")}.daily.json`);
 }
-async function refreshAnswerProbe(input, base, apiKey) {
-  const now2 = input.now ?? Date.now;
-  const results = await probeOpenRouterProviders({
-    model: input.model,
-    providers: base.providers,
-    apiKey,
-    ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {},
-    ...input.now ? { now: input.now } : {},
-    ...input.probeTimeoutMs === void 0 ? {} : { timeoutMs: input.probeTimeoutMs },
-    ...input.probeMaxCandidates === void 0 ? {} : { maxCandidates: input.probeMaxCandidates }
-  });
-  const answered = results.filter((result) => result.answered).sort((left, right) => left.latencyMs - right.latencyMs).map((result) => ({ provider: result.provider, latencyMs: result.latencyMs }));
-  const silent = results.filter((result) => !result.answered);
-  if (answered.length === 0) {
+async function readDailyRouting(input) {
+  try {
+    const row = JSON.parse(await readFile19(dailyCachePath(input), "utf8"));
+    if (row.policy !== "cost-daily-v1" || row.model !== input.model || !Number.isFinite(row.fetchedAt) || !Array.isArray(row.providers) || !row.providers.length || row.providers.length > 3 || !row.providers.every((provider) => typeof provider === "string" && provider.length > 0) || !Array.isArray(row.ranking) || !row.ranking.every((entry) => entry && typeof entry.provider === "string" && Number.isFinite(entry.effectiveInputPrice) && entry.effectiveInputPrice >= 0 && Number.isFinite(entry.cacheShare) && entry.cacheShare >= 0 && entry.cacheShare <= 1) || !row.providers.every((provider) => row.ranking.some((entry) => entry.provider === provider)))
+      return void 0;
+    return {
+      policy: "cost-daily-v1",
+      model: row.model,
+      fetchedAt: row.fetchedAt,
+      providers: row.providers,
+      ranking: row.ranking,
+      ...Array.isArray(row.input) ? { input: row.input.filter((value) => value === "text" || value === "image") } : {},
+      ...cachedLimits(row.limits) ? { limits: cachedLimits(row.limits) } : {}
+    };
+  } catch {
     return void 0;
   }
-  await writeProbeCache(input.cacheDir, {
+}
+function dailyDecision(row, source) {
+  return decision(row.model, row.providers, OPENROUTER_UPTIME_BAR_RELAXED, source, "daily effective input cost; seven-day cache shares; answer-probed", true, row.input, row.limits);
+}
+async function buildDailyRouting(input) {
+  const now2 = input.now ?? Date.now;
+  const response = await (input.fetchImpl ?? fetch)(`${OPENROUTER_ENDPOINTS_BASE_URL}/${input.model}/endpoints`, {
+    signal: AbortSignal.timeout(input.timeoutMs ?? OPENROUTER_ROUTING_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status}`);
+  const { endpoints, contextLength, inputModalities } = parseOpenRouterEndpoints(await response.json());
+  const eligible = [...new Set(endpoints.filter((endpoint2) => endpoint2.tools && endpoint2.uptime >= OPENROUTER_UPTIME_BAR_RELAXED && endpoint2.promptPrice !== void 0 && (contextLength === void 0 || endpoint2.contextLength >= contextLength)).map((endpoint2) => endpoint2.provider))];
+  if (!eligible.length)
+    throw new Error("no priced provider met the tools/context/95% gate");
+  const [traffic, probes] = await Promise.all([
+    readOpenRouterTraffic({
+      model: input.model,
+      cacheDir: input.cacheDir,
+      ...input.historyRoomsDir ? { roomsDir: input.historyRoomsDir } : {},
+      apiKey: input.apiKey,
+      now: now2(),
+      fetchImpl: input.fetchImpl,
+      timeoutMs: input.timeoutMs
+    }),
+    probeOpenRouterProviders({
+      model: input.model,
+      providers: eligible,
+      apiKey: input.apiKey,
+      fetchImpl: input.fetchImpl,
+      now: input.now,
+      timeoutMs: input.probeTimeoutMs,
+      // Gate every eligible provider once per day, rather than using the old
+      // uptime-first six as a proxy for the cheapest qualified set.
+      maxCandidates: input.probeMaxCandidates ?? eligible.length
+    })
+  ]);
+  const ranking = rankOpenRouterProviders(endpoints, contextLength, traffic, probes.filter((probe) => probe.answered).map((probe) => probe.provider));
+  if (!ranking.length)
+    throw new Error("no eligible provider answered the text probe");
+  const providers = ranking.slice(0, 3).map((row2) => row2.provider);
+  const row = {
+    policy: "cost-daily-v1",
     model: input.model,
     fetchedAt: now2(),
-    answered
-  }).catch(() => void 0);
-  const dropped = silent.length ? `dropped ${silent.map((result) => `${result.provider} (${result.note ?? "no answer"})`).join(", ")}` : "every candidate answered";
-  return decision(input.model, answered.map((entry) => entry.provider), base.bar, base.source, `answer-probed, fastest first; ${dropped}`, true, base.input, base.limits);
+    providers,
+    ranking,
+    input: piInputModalities(inputModalities),
+    limits: openRouterModelLimits(endpoints, providers)
+  };
+  await writePrivateFileAtomically(dailyCachePath(input), `${JSON.stringify(row, null, 2)}
+`).catch(() => void 0);
+  return row;
 }
+var dailyAttempts = /* @__PURE__ */ new Map();
 async function resolveOpenRouterRouting(input) {
-  const base = await resolveUptimeRouting(input);
+  const cached = await readDailyRouting(input);
   const override = input.providerOverride?.trim();
   if (override) {
+    const base = cached ? dailyDecision(cached, "cache") : await resolveUptimeRouting(input);
     return decision(input.model, [override], base.bar, base.source, "pinned to one provider after an empty completion", false, base.input, base.limits);
   }
-  const apiKey = input.apiKey?.trim();
-  if (!apiKey || base.providers.length < 2)
-    return base;
+  if (!input.apiKey?.trim())
+    return resolveUptimeRouting(input);
   const now2 = input.now ?? Date.now;
-  const probe = await readProbeCache(input.cacheDir, input.model);
-  if (probe && now2() - probe.fetchedAt < OPENROUTER_PROBE_CACHE_TTL_MS) {
-    const answered = answeringProviders(probe, base.providers);
-    if (answered.length > 0) {
-      return decision(input.model, answered, base.bar, base.source, "answer-probed, cached", true, base.input, base.limits);
-    }
-  }
+  if (cached && now2() - cached.fetchedAt < OPENROUTER_ROUTING_CACHE_TTL_MS)
+    return dailyDecision(cached, "cache");
   const key = `${input.cacheDir}\0${input.model}`;
-  let refresh2 = inFlightProbes.get(key);
-  if (!refresh2) {
-    const tracked = refreshAnswerProbe(input, base, apiKey).catch(() => void 0).finally(() => {
-      if (inFlightProbes.get(key) === tracked)
-        inFlightProbes.delete(key);
+  let attempt = dailyAttempts.get(key);
+  if (!attempt || now2() - attempt.startedAt >= OPENROUTER_ROUTING_CACHE_TTL_MS) {
+    const result = buildDailyRouting(input).then((row) => dailyDecision(row, "live")).catch(async (error) => {
+      const base = cached ? dailyDecision(cached, "stale-cache") : await resolveUptimeRouting(input);
+      return { ...base, line: `${base.line}; daily ranking unavailable: ${error instanceof Error ? error.message : String(error)}` };
     });
-    inFlightProbes.set(key, tracked);
-    refresh2 = tracked;
+    attempt = { startedAt: now2(), result };
+    dailyAttempts.set(key, attempt);
   }
-  return { ...base, refresh: refresh2 };
+  if (cached)
+    return { ...dailyDecision(cached, "stale-cache"), refresh: attempt.result };
+  return attempt.result;
 }
 function withOpenRouterModelRouting(value, pin) {
   const root = value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
@@ -34389,7 +34626,7 @@ function openRouterRoutingInput(config, selection, fetchImpl, extra) {
     openRouterRouting: {
       model,
       cacheDir: config.openRouterRoutingCacheDir,
-      ...apiKey ? { apiKey } : {},
+      ...apiKey ? { apiKey, historyRoomsDir: resolve21(config.openRouterRoutingCacheDir, "../rooms") } : {},
       ...fetchImpl ? { fetchImpl } : {},
       ...extra?.providerOverride ? { providerOverride: extra.providerOverride } : {},
       ...extra?.onDecision ? { onDecision: extra.onDecision } : {}
@@ -34398,9 +34635,9 @@ function openRouterRoutingInput(config, selection, fetchImpl, extra) {
 }
 
 // apps/body/dist/provider-key-store.js
-import { chmod as chmod5, mkdir as mkdir15, readFile as readFile19, writeFile as writeFile12 } from "node:fs/promises";
+import { chmod as chmod5, mkdir as mkdir15, readFile as readFile20, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import { dirname as dirname16, resolve as resolve21 } from "node:path";
+import { dirname as dirname16, resolve as resolve22 } from "node:path";
 var PROVIDER_KEY_ENV_VARS = {
   openrouter: "OPENROUTER_API_KEY",
   openai: "OPENAI_API_KEY",
@@ -34410,12 +34647,12 @@ var PROVIDER_KEY_ENV_VARS = {
 };
 var GOOGLE_ENV_ALIAS = "GEMINI_API_KEY";
 function providerKeyStorePath(env = process.env) {
-  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve21(homedir11(), ".config");
-  return resolve21(configRoot, "beeline", "providers.json");
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve22(homedir11(), ".config");
+  return resolve22(configRoot, "beeline", "providers.json");
 }
 async function readProviderKeyStore(env = process.env) {
   const path = providerKeyStorePath(env);
-  const raw = await readFile19(path, "utf8").catch(() => void 0);
+  const raw = await readFile20(path, "utf8").catch(() => void 0);
   if (!raw)
     return {};
   try {
@@ -34789,12 +35026,12 @@ function parseConnectSubscriptions(value) {
   ];
 }
 async function readMachineId(env = process.env) {
-  const configDir = resolve22(env.XDG_CONFIG_HOME ?? resolve22(homedir12(), ".config"), "beeline");
-  const machineIdPath = resolve22(configDir, "machine-id");
+  const configDir = resolve23(env.XDG_CONFIG_HOME ?? resolve23(homedir12(), ".config"), "beeline");
+  const machineIdPath = resolve23(configDir, "machine-id");
   let machineId;
   let machineName = hostname();
   try {
-    const existing = await readFile20(machineIdPath, "utf8");
+    const existing = await readFile21(machineIdPath, "utf8");
     machineId = existing.trim();
     if (!/^[0-9a-f-]{32,}$/.test(machineId))
       throw new Error("invalid persisted machine id");
@@ -34863,7 +35100,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve22(layout.binDir, "beeline"),
+    binary: resolve23(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -34895,7 +35132,7 @@ async function writeProviderEnv(selection, agentPubkey) {
   const values = providerEnvironment(selection);
   if (Object.keys(values).length === 0)
     return void 0;
-  const path = resolve22(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
+  const path = resolve23(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
   await mkdir16(dirname17(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
   await writeFile13(path, `${contents}
@@ -34965,7 +35202,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 = resolve22(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
+  const grantPath = resolve23(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
@@ -35050,12 +35287,12 @@ async function runConnectFinishCommand(path) {
     throw new Error("connect-finish may run only from the canonical installed Beeline launcher");
   }
   try {
-    const grant = JSON.parse(await readFile20(resolve22(path), "utf8"));
+    const grant = JSON.parse(await readFile21(resolve23(path), "utf8"));
     if (!isDevicePairingGrant(grant))
       throw new Error("device connection grant is invalid");
     const connected = await completeDevicePairing(grant);
-    await unlink5(resolve22(path));
-    const providerEnv = grant.llmEnvFile ? await readFile20(grant.llmEnvFile, "utf8").catch(() => "") : "";
+    await unlink5(resolve23(path));
+    const providerEnv = grant.llmEnvFile ? await readFile21(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 });
     if (model) {
@@ -35081,11 +35318,11 @@ init_self_update();
 // apps/body/dist/machine-helper.js
 import { mkdir as mkdir30, rename as rename14, stat as stat12, writeFile as writeFile23 } from "node:fs/promises";
 import { homedir as homedir19 } from "node:os";
-import { dirname as dirname31, resolve as resolve49 } from "node:path";
+import { dirname as dirname31, resolve as resolve50 } from "node:path";
 
 // apps/body/dist/agent-runtime.js
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname30, join as join22, resolve as resolve47 } from "node:path";
+import { dirname as dirname30, join as join22, resolve as resolve48 } from "node:path";
 
 // apps/body/dist/model-availability.js
 var SECRET_VALUE = /(?:token|key|secret|password)=?[^\s,;]*/gi;
@@ -35147,8 +35384,8 @@ async function applyRuntimeModelPreflight(config, agent, selection, validate = v
 
 // apps/body/dist/model-catalog-sync.js
 import { createHash as createHash10 } from "node:crypto";
-import { readFile as readFile21, writeFile as writeFile14 } from "node:fs/promises";
-import { resolve as resolve23 } from "node:path";
+import { readFile as readFile22, writeFile as writeFile14 } from "node:fs/promises";
+import { resolve as resolve24 } from "node:path";
 var MODEL_CATALOG_PROBE_TIMEOUT_MS = 3e4;
 var MODEL_CATALOG_HASH_FILE = "model-catalog.sha256";
 function modelCatalogHash(options, selection, startupUnavailable) {
@@ -35173,7 +35410,7 @@ async function withTimeout(work, timeoutMs, what) {
 async function syncAgentModelCatalog(input) {
   const log2 = input.log ?? ((line) => console.log(line));
   const fetchCatalog = input.fetchCatalog ?? fetchAgentModelCatalog;
-  const hashPath = resolve23(input.runtimeDir, MODEL_CATALOG_HASH_FILE);
+  const hashPath = resolve24(input.runtimeDir, MODEL_CATALOG_HASH_FILE);
   try {
     const configuration = await input.api.execute("getAgentConfiguration", {
       agentId: input.agentId
@@ -35185,7 +35422,7 @@ async function syncAgentModelCatalog(input) {
     const { catalog } = await withTimeout(fetchCatalog(input.agent, input.agentEnv, input.startupUnavailable ? void 0 : selection), input.timeoutMs ?? MODEL_CATALOG_PROBE_TIMEOUT_MS, "model catalog probe");
     const effectiveCatalog = input.startupUnavailable ? catalog : withEffectiveCurrentValues(catalog, selection);
     const hash = modelCatalogHash(effectiveCatalog, selection, input.startupUnavailable);
-    const previous = await readFile21(hashPath, "utf8").catch(() => "");
+    const previous = await readFile22(hashPath, "utf8").catch(() => "");
     if (!input.force && previous.trim() === hash)
       return "unchanged";
     await input.api.execute("postAgentModelCatalog", {
@@ -35219,10 +35456,10 @@ var LOGIN_URL = /https:\/\/login\.tailscale\.com\/[A-Za-z0-9_/-]+/u;
 function clipped(value) {
   return value.length <= OUTPUT_LIMIT ? value : value.slice(value.length - OUTPUT_LIMIT);
 }
-var runTailscaleCommand = (command, args) => new Promise((resolve52) => {
+var runTailscaleCommand = (command, args) => new Promise((resolve53) => {
   execFile9(command, [...args], { timeout: COMMAND_TIMEOUT_MS, maxBuffer: OUTPUT_LIMIT * 2 }, (error, stdout6, stderr) => {
     const code = error && "code" in error && typeof error.code === "number" ? error.code : error ? null : 0;
-    resolve52({ code, stdout: clipped(stdout6), stderr: clipped(stderr) });
+    resolve53({ code, stdout: clipped(stdout6), stderr: clipped(stderr) });
   });
 });
 function loginUrlFrom(status, output) {
@@ -35994,8 +36231,8 @@ import { dirname as dirname18 } from "node:path";
 // apps/body/dist/browser-share.js
 var shares = /* @__PURE__ */ new Map();
 function opened(socket) {
-  return new Promise((resolve52, reject) => {
-    socket.once("open", resolve52);
+  return new Promise((resolve53, reject) => {
+    socket.once("open", resolve53);
     socket.once("error", reject);
   });
 }
@@ -36171,18 +36408,18 @@ var BrowserShareHost = class {
         })().catch((error) => socket.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) })));
       });
     });
-    await new Promise((resolve52, reject) => {
+    await new Promise((resolve53, reject) => {
       this.server.once("error", reject);
       this.server.listen(this.socketPath, () => {
         this.server.off("error", reject);
-        resolve52();
+        resolve53();
       });
     });
     chmodSync2(this.socketPath, 384);
   }
   async stop() {
     if (this.server)
-      await new Promise((resolve52) => this.server.close(() => resolve52()));
+      await new Promise((resolve53) => this.server.close(() => resolve53()));
     this.server = void 0;
     rmSync3(this.socketPath, { force: true });
   }
@@ -36192,16 +36429,16 @@ var BrowserShareHost = class {
 import { execFile as execFile19 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
-import { lstat as lstat9, mkdir as mkdir28, readdir as readdir13, realpath as realpath4, rm as rm20 } from "node:fs/promises";
-import { dirname as dirname28, relative as relative4, resolve as resolve42, sep as sep4 } from "node:path";
+import { lstat as lstat10, mkdir as mkdir28, readdir as readdir14, realpath as realpath4, rm as rm20 } from "node:fs/promises";
+import { dirname as dirname28, relative as relative4, resolve as resolve43, sep as sep4 } from "node:path";
 import { promisify as promisify13 } from "node:util";
 
 // apps/body/dist/grant-runner.js
 import { execFile as execFile11 } from "node:child_process";
 import { createHash as createHash11, randomBytes as randomBytes9, randomUUID as randomUUID11 } from "node:crypto";
-import { chmod as chmod7, mkdir as mkdir17, readFile as readFile22, readdir as readdir6, rename as rename9, rm as rm13, rmdir, stat as stat9, writeFile as writeFile15 } from "node:fs/promises";
+import { chmod as chmod7, mkdir as mkdir17, readFile as readFile23, readdir as readdir7, rename as rename9, rm as rm13, rmdir, stat as stat9, writeFile as writeFile15 } from "node:fs/promises";
 import { createServer as createServer4 } from "node:http";
-import { dirname as dirname20, resolve as resolve25 } from "node:path";
+import { dirname as dirname20, resolve as resolve26 } from "node:path";
 
 // packages/api-contract/dist/surface-capabilities.js
 var SURFACE_CAPABILITY_TABLE = {
@@ -36232,7 +36469,7 @@ function surfaceAllows(surface, capability) {
 import { execFile as execFile10, spawnSync } from "node:child_process";
 import { lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync8, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { basename as basename7, dirname as dirname19, isAbsolute as isAbsolute3, relative, resolve as resolve24, sep } from "node:path";
+import { basename as basename7, dirname as dirname19, isAbsolute as isAbsolute3, relative, resolve as resolve25, sep } from "node:path";
 var DEFAULT_SANDBOX_POLICY = "bwrap";
 function isSandboxPolicy(value) {
   return value === "bwrap" || value === "off";
@@ -36277,7 +36514,7 @@ function harnessHomeStateDirs(agentCommand, home = homedir13()) {
     return [];
   for (const { match, dirs } of HARNESS_HOME_STATE_DIRS) {
     if (match.test(agentCommand))
-      return dirs.map((dir) => resolve24(home, dir));
+      return dirs.map((dir) => resolve25(home, dir));
   }
   return [];
 }
@@ -36297,10 +36534,10 @@ function credentialMaskPaths(extraPaths, home = homedir13(), stat14 = (path) =>
     return void 0;
   }
 }, requiredPaths = []) {
-  const required = new Set(requiredPaths.map((path) => resolve24(path)));
+  const required = new Set(requiredPaths.map((path) => resolve25(path)));
   const candidates = [
-    ...KNOWN_CREDENTIAL_MASK_PATHS.map((entry) => resolve24(home, entry)),
-    ...(extraPaths ?? []).map((entry) => resolve24(entry))
+    ...KNOWN_CREDENTIAL_MASK_PATHS.map((entry) => resolve25(home, entry)),
+    ...(extraPaths ?? []).map((entry) => resolve25(entry))
   ];
   const seen = /* @__PURE__ */ new Set();
   const masks = [];
@@ -36325,10 +36562,10 @@ function siblingAgentMaskPaths(ownRuntimeDir, listAgentDirs = (agentsRoot) => {
     return [];
   }
 }) {
-  const own = resolve24(ownRuntimeDir);
+  const own = resolve25(ownRuntimeDir);
   const agentsRoot = dirname19(own);
   const ownName = basename7(own).toLowerCase();
-  return listAgentDirs(agentsRoot).filter((name) => name.toLowerCase() !== ownName).map((name) => ({ path: resolve24(agentsRoot, name), kind: "dir" })).sort((a2, b) => a2.path.localeCompare(b.path));
+  return listAgentDirs(agentsRoot).filter((name) => name.toLowerCase() !== ownName).map((name) => ({ path: resolve25(agentsRoot, name), kind: "dir" })).sort((a2, b) => a2.path.localeCompare(b.path));
 }
 var DEFAULT_SANDBOX_DEVICES = ["/dev/kvm"];
 function grantedSandboxDevices(result) {
@@ -36358,7 +36595,7 @@ function sandboxDevicePath(target) {
   const trimmed = target.trim();
   if (!isAbsolute3(trimmed))
     return void 0;
-  const path = resolve24(trimmed);
+  const path = resolve25(trimmed);
   return path.startsWith("/dev/") ? path : void 0;
 }
 function isUnderTmp(path) {
@@ -36370,7 +36607,7 @@ function normalize(paths) {
   for (const path of paths) {
     if (!path)
       continue;
-    seen.add(resolve24(path));
+    seen.add(resolve25(path));
   }
   return Array.from(seen).sort();
 }
@@ -36407,14 +36644,14 @@ function sandboxMountPlan(spec) {
   const requiredMounts = [];
   const boundaryMasks = [];
   if (shared) {
-    const assetRoot = resolve24(shared.assetRoot);
-    const agentsRoot = dirname19(resolve24(shared.agentRuntimeDir));
+    const assetRoot = resolve25(shared.assetRoot);
+    const agentsRoot = dirname19(resolve25(shared.agentRuntimeDir));
     const workspacesRoot = dirname19(dirname19(assetRoot));
     boundaryMasks.push({ path: workspacesRoot, kind: "dir" }, { path: agentsRoot, kind: "dir" });
     const add = (path, mode, target = path) => {
-      requiredMounts.push({ source: resolve24(path), target: resolve24(target), mode });
+      requiredMounts.push({ source: resolve25(path), target: resolve25(target), mode });
     };
-    const cwd = resolve24(spec.cwd);
+    const cwd = resolve25(spec.cwd);
     const relativeCwd = relative(agentsRoot, cwd);
     if (relativeCwd === "" || relativeCwd !== ".." && !relativeCwd.startsWith(`..${sep}`) && !isAbsolute3(relativeCwd))
       add(cwd, spec.mode === "edit" ? "bind" : "ro-bind");
@@ -36423,34 +36660,34 @@ function sandboxMountPlan(spec) {
       add(shared.privateRoot, "bind");
     if (shared.privateAssetRoot && shared.isolatedCategories?.length)
       add(shared.privateAssetRoot, "bind");
-    add(resolve24(shared.agentRuntimeDir, "runtime.json"), "ro-bind");
+    add(resolve25(shared.agentRuntimeDir, "runtime.json"), "ro-bind");
     for (const path of spec.additionalWritablePaths ?? []) {
-      const rel = relative(cwd, resolve24(path));
+      const rel = relative(cwd, resolve25(path));
       if (rel && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute3(rel))
         add(path, "bind");
     }
-    add(resolve24(assetRoot, "cache"), "bind");
-    const source = (category, suffix) => shared.privateAssetRoot && shared.isolatedCategories?.includes(category) ? resolve24(shared.privateAssetRoot, suffix) : resolve24(assetRoot, suffix);
+    add(resolve25(assetRoot, "cache"), "bind");
+    const source = (category, suffix) => shared.privateAssetRoot && shared.isolatedCategories?.includes(category) ? resolve25(shared.privateAssetRoot, suffix) : resolve25(assetRoot, suffix);
     if (shared.privateAssetRoot) {
       for (const suffix of shared.isolatedCategories?.includes("package-cache") ? PACKAGE_CACHE_DIRS : [])
-        add(resolve24(shared.privateAssetRoot, "cache", suffix), "bind", resolve24(assetRoot, "cache", suffix));
+        add(resolve25(shared.privateAssetRoot, "cache", suffix), "bind", resolve25(assetRoot, "cache", suffix));
       for (const [category, suffix] of [
         ["codex-download-cache", "cache/codex/download"],
         ["codex-plugin-cache", "cache/codex/plugins"]
       ]) {
         if (shared.isolatedCategories?.includes(category))
-          add(resolve24(shared.privateAssetRoot, suffix), "bind", resolve24(assetRoot, suffix));
+          add(resolve25(shared.privateAssetRoot, suffix), "bind", resolve25(assetRoot, suffix));
       }
     }
     if (shared.codexHome) {
-      add(source("codex-download-cache", "cache/codex/download"), "bind", resolve24(shared.codexHome, "cache"));
-      add(source("codex-plugin-cache", "cache/codex/plugins"), "bind", resolve24(shared.codexHome, "plugins/cache"));
+      add(source("codex-download-cache", "cache/codex/download"), "bind", resolve25(shared.codexHome, "cache"));
+      add(source("codex-plugin-cache", "cache/codex/plugins"), "bind", resolve25(shared.codexHome, "plugins/cache"));
     }
     if (shared.packageHome) {
-      add(source("package-cache", "cache/cargo/registry"), "bind", resolve24(shared.packageHome, ".cargo/registry"));
+      add(source("package-cache", "cache/cargo/registry"), "bind", resolve25(shared.packageHome, ".cargo/registry"));
     }
     for (const name of ["tools", "avd-base"])
-      add(resolve24(assetRoot, name), "ro-bind");
+      add(resolve25(assetRoot, name), "ro-bind");
   }
   return {
     ...spec.mode === "edit" ? { rootWritable: true } : {},
@@ -36458,7 +36695,7 @@ function sandboxMountPlan(spec) {
     writable,
     quotaTmpfs: spec.workbench ? [
       {
-        target: resolve24(spec.workbench.dir),
+        target: resolve25(spec.workbench.dir),
         maxBytes: spec.workbench.maxBytes,
         maxInodes: spec.workbench.maxInodes,
         blockGit: true
@@ -36522,7 +36759,7 @@ function buildBwrapArgv(input) {
   for (const binding of quotaTmpfs) {
     args.push("--dir", binding.target, "--size", String(binding.maxBytes), "--tmpfs", binding.target);
     if (binding.blockGit)
-      args.push("--ro-bind", "/dev/null", resolve24(binding.target, ".git"));
+      args.push("--ro-bind", "/dev/null", resolve25(binding.target, ".git"));
   }
   args.push("--chdir", input.cwd);
   args.push("--die-with-parent");
@@ -36594,7 +36831,7 @@ var INSTALL_RETRY_AFTER_HOURS = 24;
 var INSTALL_RETRY_AFTER_MS = INSTALL_RETRY_AFTER_HOURS * 60 * 6e4;
 var INSTALL_FAILURE_MARKER = "bubblewrap-install-failed";
 function installFailureMarker(stateDir) {
-  return resolve24(stateDir, INSTALL_FAILURE_MARKER);
+  return resolve25(stateDir, INSTALL_FAILURE_MARKER);
 }
 function readInstallFailure(stateDir) {
   if (!stateDir)
@@ -36623,7 +36860,7 @@ function clearInstallFailure(stateDir) {
   } catch {
   }
 }
-var runSandboxInstallCommand = (command, args) => new Promise((resolve52) => {
+var runSandboxInstallCommand = (command, args) => new Promise((resolve53) => {
   execFile10(command, [...args], {
     timeout: INSTALL_TIMEOUT_MS,
     maxBuffer: INSTALL_OUTPUT_LIMIT * 2,
@@ -36633,7 +36870,7 @@ var runSandboxInstallCommand = (command, args) => new Promise((resolve52) => {
   }, (error, stdout6, stderr) => {
     const code = error && "code" in error && typeof error.code === "number" ? error.code : error ? null : 0;
     const output = [stdout6, stderr].join("").trim();
-    resolve52({ code, output: output || (error ? error.message : "") });
+    resolve53({ code, output: output || (error ? error.message : "") });
   });
 });
 function lastLine2(output, fallback) {
@@ -36742,10 +36979,10 @@ var SANDBOX_STARTED_SCRIPT = ['printf "%s\\n" "$1" >&2', "shift", 'exec "$@"'].j
 var ROOM_SANDBOX_UNAVAILABLE = "this Room cannot run granted commands: a Room promises a read-only filesystem and that promise is enforced by bubblewrap, which is not usable on this host. Open a corner with open_corner and run it there, where writes belong.";
 var ROOM_WRITE_REFUSED_NOTE = "[beeline] the Room filesystem is read-only outside your scratch directory, so this write was refused by the kernel. Open a corner with open_corner to change files.";
 function operatorSecretsPath(env = process.env) {
-  return resolve25(dirname20(providerKeyStorePath(env)), "secrets.json");
+  return resolve26(dirname20(providerKeyStorePath(env)), "secrets.json");
 }
 async function readOperatorSecrets(env = process.env) {
-  const raw = await readFile22(operatorSecretsPath(env), "utf8").catch(() => void 0);
+  const raw = await readFile23(operatorSecretsPath(env), "utf8").catch(() => void 0);
   if (!raw)
     return {};
   try {
@@ -36958,7 +37195,7 @@ ${ROOM_WRITE_REFUSED_NOTE}` : outcome.output, secrets), cap);
       return;
     let bytes;
     for (const candidate of candidates) {
-      bytes = await readFile22(candidate).catch(() => void 0);
+      bytes = await readFile23(candidate).catch(() => void 0);
       if (bytes)
         break;
     }
@@ -36978,8 +37215,8 @@ function scriptCandidates(cwd, scratch, argv) {
   if (!argument)
     return [];
   const paths = [
-    resolve25(cwd, argument.path),
-    ...scratch ? [resolve25(scratch, argument.path)] : []
+    resolve26(cwd, argument.path),
+    ...scratch ? [resolve26(scratch, argument.path)] : []
   ];
   return [...new Set(paths)];
 }
@@ -37161,13 +37398,13 @@ function captureConnectionUsage(recorder, turn, calls) {
 }
 
 // apps/body/dist/model-context-window.js
-import { readFile as readFile23 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 async function modelContextWindowTokens(model, piHome) {
   if (!model || !piHome)
     return void 0;
   try {
-    const catalog = JSON.parse(await readFile23(join12(piHome, "models.json"), "utf8"));
+    const catalog = JSON.parse(await readFile24(join12(piHome, "models.json"), "utf8"));
     const parts = model.split("/");
     const preferredProvider = parts.length > 2 ? parts.shift() : void 0;
     const modelId = parts.join("/");
@@ -37183,11 +37420,11 @@ async function modelContextWindowTokens(model, piHome) {
 }
 
 // apps/body/dist/turn-usage.js
-import { readFile as readFile25 } from "node:fs/promises";
+import { readFile as readFile26 } from "node:fs/promises";
 
 // apps/body/dist/pi-turn-record.js
-import { readdir as readdir7, readFile as readFile24 } from "node:fs/promises";
-import { resolve as resolve26 } from "node:path";
+import { readdir as readdir8, readFile as readFile25 } from "node:fs/promises";
+import { resolve as resolve27 } from "node:path";
 function summarizeProviderError(errorMessage2) {
   const trimmed = errorMessage2.trim();
   const statusMatch = /^(\d{3}):\s*([\s\S]*)$/.exec(trimmed);
@@ -37214,7 +37451,7 @@ async function piSessionFilePath(agentEnv, sessionId) {
 }
 async function sessionFileFromMap(home, sessionId) {
   try {
-    const raw = await readFile24(resolve26(home, ".pi", "pi-acp", "session-map.json"), "utf8");
+    const raw = await readFile25(resolve27(home, ".pi", "pi-acp", "session-map.json"), "utf8");
     const map = JSON.parse(raw);
     const file = map.sessions?.[sessionId]?.sessionFile;
     return typeof file === "string" && file ? file : void 0;
@@ -37223,25 +37460,25 @@ async function sessionFileFromMap(home, sessionId) {
   }
 }
 async function sessionFileFromLayout(piDir, sessionId) {
-  const sessionsRoot = resolve26(piDir, "sessions");
+  const sessionsRoot = resolve27(piDir, "sessions");
   const suffix = `_${sessionId}.jsonl`;
   let projects;
   try {
-    projects = await readdir7(sessionsRoot);
+    projects = await readdir8(sessionsRoot);
   } catch {
     return void 0;
   }
   for (const project of projects) {
-    const dir = resolve26(sessionsRoot, project);
+    const dir = resolve27(sessionsRoot, project);
     let files;
     try {
-      files = await readdir7(dir);
+      files = await readdir8(dir);
     } catch {
       continue;
     }
     const match = files.find((file) => file.endsWith(suffix));
     if (match)
-      return resolve26(dir, match);
+      return resolve27(dir, match);
   }
   return void 0;
 }
@@ -37256,7 +37493,7 @@ async function readPiTurnRecord(input) {
     return void 0;
   let raw;
   try {
-    raw = await readFile24(file, "utf8");
+    raw = await readFile25(file, "utf8");
   } catch {
     return void 0;
   }
@@ -37315,7 +37552,7 @@ async function readUsageCalls(input, latestTurn) {
   const file = await piSessionFilePath(input.agentEnv, input.sessionId);
   if (!file)
     return latestTurn ? void 0 : [];
-  const raw = await readFile25(file, "utf8").catch(() => void 0);
+  const raw = await readFile26(file, "utf8").catch(() => void 0);
   if (raw === void 0)
     return void 0;
   const calls = [];
@@ -37543,11 +37780,11 @@ async function runServerCommandIntake(options) {
               if (attempt === 3)
                 throw error;
               const waitMs = Math.max(250 * 2 ** attempt, error instanceof DaemonApiError ? error.retryAfterMs ?? 0 : 0);
-              await new Promise((resolve52) => {
+              await new Promise((resolve53) => {
                 const done = () => {
                   clearTimeout(timer);
                   signal?.removeEventListener("abort", done);
-                  resolve52();
+                  resolve53();
                 };
                 const timer = setTimeout(done, waitMs);
                 signal?.addEventListener("abort", done, { once: true });
@@ -37649,11 +37886,11 @@ async function runServerCommandIntake(options) {
         }
       }
       options.onPoll?.();
-      const reconcile = await new Promise((resolve52) => {
+      const reconcile = await new Promise((resolve53) => {
         const done = (needed) => {
           signal?.removeEventListener("abort", aborted);
           wake = void 0;
-          resolve52(needed);
+          resolve53(needed);
         };
         const aborted = () => done(false);
         wake = done;
@@ -37696,9 +37933,9 @@ async function runServerCommandIntake(options) {
 import { execFile as execFile17 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync9 } from "node:fs";
-import { mkdir as mkdir27, readFile as readFile32, writeFile as writeFile21 } from "node:fs/promises";
+import { mkdir as mkdir27, readFile as readFile33, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir17, hostname as hostname4 } from "node:os";
-import { dirname as dirname26, join as join20, resolve as resolve40 } from "node:path";
+import { dirname as dirname26, join as join20, resolve as resolve41 } from "node:path";
 import { promisify as promisify11 } from "node:util";
 
 // apps/body/dist/machine-host.js
@@ -37706,16 +37943,16 @@ import { execFile as execFile12 } from "node:child_process";
 import { hostname as hostname2 } from "node:os";
 async function machineHost() {
   const local = hostname2();
-  const tailscaleName = await new Promise((resolve52) => {
+  const tailscaleName = await new Promise((resolve53) => {
     execFile12("tailscale", ["status", "--json"], { timeout: 1500, maxBuffer: 64 * 1024 }, (error, stdout6) => {
       if (error)
-        return resolve52(void 0);
+        return resolve53(void 0);
       try {
         const status = JSON.parse(stdout6);
         const name = status.BackendState === "Running" ? status.Self?.DNSName?.replace(/\.$/, "") : void 0;
-        resolve52(name || void 0);
+        resolve53(name || void 0);
       } catch {
-        resolve52(void 0);
+        resolve53(void 0);
       }
     });
   });
@@ -38522,9 +38759,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 
 // apps/body/dist/agent-home.js
 import { createHash as createHash13, randomUUID as randomUUID13 } from "node:crypto";
-import { chmod as chmod8, copyFile, lstat as lstat5, mkdir as mkdir19, readFile as readFile26, readlink, readdir as readdir8, realpath as realpath2, rename as rename10, rm as rm14, symlink as symlink2, unlink as unlink6, writeFile as writeFile17 } from "node:fs/promises";
+import { chmod as chmod8, copyFile, lstat as lstat6, mkdir as mkdir19, readFile as readFile27, readlink, readdir as readdir9, realpath as realpath2, rename as rename10, rm as rm14, symlink as symlink2, unlink as unlink6, writeFile as writeFile17 } from "node:fs/promises";
 import { homedir as homedir14 } from "node:os";
-import { basename as basename8, dirname as dirname22, join as join15, relative as relative2, resolve as resolve30, sep as sep2 } from "node:path";
+import { basename as basename8, dirname as dirname22, join as join15, relative as relative2, resolve as resolve31, sep as sep2 } from "node:path";
 
 // apps/body/dist/draw-avatar-skill.js
 var DRAW_AVATAR_SKILL_NAME = "draw-avatar";
@@ -38614,7 +38851,7 @@ set_avatar renders bounded geometry to durable image bytes and replaces your cur
 // apps/body/dist/android-agent-env.js
 import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
-import { delimiter as delimiter2, resolve as resolve27 } from "node:path";
+import { delimiter as delimiter2, resolve as resolve28 } from "node:path";
 var ANDROID_FIRST_EMULATOR_PORT = 5600;
 var ANDROID_PORT_SLOTS = 100;
 function androidAgentEnv(input) {
@@ -38622,25 +38859,25 @@ function androidAgentEnv(input) {
   const sdk = [
     env.ANDROID_HOME,
     env.ANDROID_SDK_ROOT,
-    resolve27(input.operatorHome, "android-sdk"),
-    resolve27(input.operatorHome, "Android/Sdk")
-  ].find((path) => path && existsSync7(resolve27(path, "platform-tools/adb")));
+    resolve28(input.operatorHome, "android-sdk"),
+    resolve28(input.operatorHome, "Android/Sdk")
+  ].find((path) => path && existsSync7(resolve28(path, "platform-tools/adb")));
   if (!sdk)
     return {};
-  const emulatorHome = env.ANDROID_EMULATOR_HOME ?? resolve27(input.operatorHome, ".android");
-  const slot = createHash12("sha256").update(resolve27(input.root)).digest().readUInt32BE(0) % ANDROID_PORT_SLOTS;
+  const emulatorHome = env.ANDROID_EMULATOR_HOME ?? resolve28(input.operatorHome, ".android");
+  const slot = createHash12("sha256").update(resolve28(input.root)).digest().readUInt32BE(0) % ANDROID_PORT_SLOTS;
   const emulatorPort = ANDROID_FIRST_EMULATOR_PORT + slot * 4;
   return {
     ANDROID_HOME: sdk,
     ANDROID_SDK_ROOT: sdk,
     ANDROID_EMULATOR_HOME: emulatorHome,
-    ANDROID_AVD_HOME: env.ANDROID_AVD_HOME ?? resolve27(emulatorHome, "avd"),
+    ANDROID_AVD_HOME: env.ANDROID_AVD_HOME ?? resolve28(emulatorHome, "avd"),
     ANDROID_ADB_SERVER_PORT: String(emulatorPort + 2),
     ADB_EMU: "0",
     BEELINE_ANDROID_EMULATOR_PORT: String(emulatorPort),
     PATH: [
-      resolve27(sdk, "platform-tools"),
-      resolve27(sdk, "emulator"),
+      resolve28(sdk, "platform-tools"),
+      resolve28(sdk, "emulator"),
       input.inheritedPath ?? env.PATH
     ].filter(Boolean).join(delimiter2)
   };
@@ -38648,7 +38885,7 @@ function androidAgentEnv(input) {
 
 // apps/body/dist/beeline-skill.js
 import { readFileSync as readFileSync9 } from "node:fs";
-import { resolve as resolve28 } from "node:path";
+import { resolve as resolve29 } from "node:path";
 var USING_BEELINE_SKILL_NAME = "using-beeline";
 var BEELINE_TRIAGE_SKILL_NAME = "beeline-triage";
 var BEELINE_REVIEW_SKILL_NAME = "beeline-review";
@@ -38667,7 +38904,7 @@ function runningBeelineReleaseId(env = process.env, read2 = (path) => readFileSy
     const lib = env.BEELINE_LIB_DIR;
     if (!lib)
       return "source";
-    const manifest = JSON.parse(read2(resolve28(lib, "bundle.json")));
+    const manifest = JSON.parse(read2(resolve29(lib, "bundle.json")));
     return [manifest.version, manifest.commit].filter(Boolean).join("-") || "source";
   } catch {
     return "source";
@@ -39028,7 +39265,7 @@ var SQUIRE_GOVERNED_TOOLS = [
 var SQUIRE_GOVERNED_TOOL_SET = new Set(SQUIRE_GOVERNED_TOOLS);
 
 // apps/body/dist/host-mcp-route.js
-import { join as join14, resolve as resolve29 } from "node:path";
+import { join as join14, resolve as resolve30 } from "node:path";
 var import_yaml = __toESM(require_dist(), 1);
 init_squire_host();
 function grantedMcpServerNames(grants) {
@@ -39083,7 +39320,7 @@ function grantedSquireHostRouteNames(granted, declarations = {}) {
   });
 }
 function hostRouteEnv(hostHome) {
-  return { XDG_CONFIG_HOME: join14(resolve29(hostHome), ".config") };
+  return { XDG_CONFIG_HOME: join14(resolve30(hostHome), ".config") };
 }
 function rewriteHostMcpDeclaration(name, declaration, hostHome, resourceAuthFile, squireScope) {
   const next = { ...declaration };
@@ -39477,7 +39714,7 @@ async function withSharedClaudeLoginLock(shared, write2) {
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
-      const held = await lstat5(lock).catch(() => void 0);
+      const held = await lstat6(lock).catch(() => void 0);
       if (held && Date.now() - held.mtimeMs > CLAUDE_LOGIN_LOCK_STALE_MS) {
         await rm14(lock, { force: true });
         continue;
@@ -39494,13 +39731,13 @@ async function withSharedClaudeLoginLock(shared, write2) {
   }
 }
 async function writeBackDetachedClaudeLogin(target, source) {
-  const detached = await readFile26(target, "utf8");
+  const detached = await readFile27(target, "utf8");
   const detachedExpiresAt = claudeLoginExpiresAt(detached);
   if (detachedExpiresAt === void 0)
     return "not-newer";
   const shared = await realpath2(source);
   const isNewer = async () => {
-    const sharedExpiresAt = claudeLoginExpiresAt(await readFile26(shared, "utf8"));
+    const sharedExpiresAt = claudeLoginExpiresAt(await readFile27(shared, "utf8"));
     return sharedExpiresAt !== void 0 && detachedExpiresAt > sharedExpiresAt;
   };
   if (!await isNewer())
@@ -39523,7 +39760,7 @@ async function writeBackDetachedClaudeLogin(target, source) {
     return "busy";
   if (!written)
     return "not-newer";
-  if (await readFile26(target, "utf8") !== detached)
+  if (await readFile27(target, "utf8") !== detached)
     return "busy";
   const link2 = `${target}.beeline-link-${randomUUID13()}`;
   await symlink2(source, link2);
@@ -39531,22 +39768,22 @@ async function writeBackDetachedClaudeLogin(target, source) {
   return "linked";
 }
 async function repairRoomAgentCredentialLinks(input) {
-  const root = resolve30(input.root);
+  const root = resolve31(input.root);
   const operatorHome = input.operatorHome ?? homedir14();
   for (const credential of SHARED_CREDENTIALS) {
-    const source = resolve30(operatorHome, credential.source);
+    const source = resolve31(operatorHome, credential.source);
     if (!existsSync8(source))
       continue;
-    const target = resolve30(root, credential.dir, credential.target);
+    const target = resolve31(root, credential.dir, credential.target);
     await mkdir19(dirname22(target), { recursive: true, mode: 448 });
-    const stats = await lstat5(target).catch((error) => {
+    const stats = await lstat6(target).catch((error) => {
       if (isMissingPathError(error))
         return void 0;
       throw error;
     });
     if (stats?.isSymbolicLink()) {
       const linked = await readlink(target);
-      if (resolve30(dirname22(target), linked) === source)
+      if (resolve31(dirname22(target), linked) === source)
         continue;
     }
     if (stats) {
@@ -39563,20 +39800,20 @@ async function repairRoomAgentCredentialLinks(input) {
 }
 async function writeBackRoomClaudeLogin(input) {
   const claude = SHARED_CREDENTIALS.find((credential) => credential.dir === "claude");
-  const source = resolve30(input.operatorHome ?? homedir14(), claude.source);
+  const source = resolve31(input.operatorHome ?? homedir14(), claude.source);
   if (!existsSync8(source))
     return;
-  const target = resolve30(input.root, claude.dir, claude.target);
-  const stats = await lstat5(target).catch(() => void 0);
+  const target = resolve31(input.root, claude.dir, claude.target);
+  const stats = await lstat6(target).catch(() => void 0);
   if (!stats?.isFile())
     return;
   await writeBackDetachedClaudeLogin(target, source);
 }
 function watchRoomClaudeLogin(input) {
   const claude = SHARED_CREDENTIALS.find((credential) => credential.dir === "claude");
-  if (!existsSync8(resolve30(input.operatorHome ?? homedir14(), claude.source)))
+  if (!existsSync8(resolve31(input.operatorHome ?? homedir14(), claude.source)))
     return void 0;
-  const dir = resolve30(input.root, claude.dir);
+  const dir = resolve31(input.root, claude.dir);
   let pass = Promise.resolve();
   let watcher;
   try {
@@ -39599,23 +39836,23 @@ function watchRoomClaudeLogin(input) {
   return watcher;
 }
 async function prepareRoomAgentHome(input) {
-  const root = resolve30(input.root);
+  const root = resolve31(input.root);
   const operatorHome = input.operatorHome ?? homedir14();
   let tmpLinkReady = false;
   try {
     await mkdir19(root, { recursive: true, mode: 448 });
-    const rootStats = await lstat5(root);
+    const rootStats = await lstat6(root);
     if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) {
       throw new AgentHomeSecurityError(`agent home root is not an ordinary directory: ${root}`);
     }
     for (const subdir of HOME_SUBDIRS) {
-      const path = resolve30(root, subdir);
+      const path = resolve31(root, subdir);
       await mkdir19(path, { recursive: true, mode: 448 });
       await assertRealContainedDirectory(path, root);
     }
     try {
       const tmpLink = roomSessionTmpDir(root);
-      const tmpTarget = resolve30(root, "tmp");
+      const tmpTarget = resolve31(root, "tmp");
       if (await readlink(tmpLink).catch(() => void 0) !== tmpTarget) {
         await rm14(tmpLink, { recursive: true, force: true });
         await symlink2(tmpTarget, tmpLink);
@@ -39650,7 +39887,7 @@ async function prepareRoomAgentHome(input) {
     if (agentHomeProvisionQueues.get(root) === provision)
       agentHomeProvisionQueues.delete(root);
   }
-  const env = tmpLinkReady ? roomAgentHomeEnv(root) : { ...roomAgentHomeEnv(root), TMPDIR: resolve30(root, "tmp") };
+  const env = tmpLinkReady ? roomAgentHomeEnv(root) : { ...roomAgentHomeEnv(root), TMPDIR: resolve31(root, "tmp") };
   return {
     ...env,
     ...androidAgentEnv({
@@ -39669,11 +39906,11 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     ...isReviewer ? [{ name: BEELINE_REVIEW_SKILL_NAME, content: beelineReviewSkillMarkdown(skillReleaseId) }] : []
   ];
   const shared = await resolveSharedSkillSources(operatorHome, sharedSkills);
-  await provisionManagedSkillsDir(resolve30(root, skillDir, "skills"), managedSkills, shared, sharedSkills.length === 0);
+  await provisionManagedSkillsDir(resolve31(root, skillDir, "skills"), managedSkills, shared, sharedSkills.length === 0);
   for (const config of HARNESS_MCP_CONFIGS) {
     try {
-      const source = resolve30(operatorHome, config.toml);
-      const target = resolve30(root, config.dir, "config.toml");
+      const source = resolve31(operatorHome, config.toml);
+      const target = resolve31(root, config.dir, "config.toml");
       const mcpSection = existsSync8(source) ? localHarnessMcpToml(readFileSync10(source, "utf8")) : void 0;
       const section = config.dir === "codex" ? [CODEX_ROOM_AGENT_LOCKDOWN_TOML, CODEX_ROOM_WEB_SEARCH_TOML, mcpSection].filter(Boolean).join("\n") : mcpSection;
       if (!section) {
@@ -39688,11 +39925,11 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     }
   }
   try {
-    const gooseConfigDir = resolve30(root, "goose", "config");
+    const gooseConfigDir = resolve31(root, "goose", "config");
     await mkdir19(gooseConfigDir, { recursive: true, mode: 448 });
     for (const name of GOOSE_SHARED_CONFIG_FILES) {
-      const source = resolve30(operatorHome, ".config", "goose", name);
-      const target = resolve30(gooseConfigDir, name);
+      const source = resolve31(operatorHome, ".config", "goose", name);
+      const target = resolve31(gooseConfigDir, name);
       if (existsSync8(source)) {
         const body = readFileSync10(source, "utf8");
         await writeIsolatedHarnessFile(target, name === "config.yaml" ? localGooseConfig(body) : body);
@@ -39706,8 +39943,8 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     console.warn("[body] operator Goose configuration passthrough failed:", error);
   }
   try {
-    const claudeJson = resolve30(operatorHome, ".claude.json");
-    const claudeTarget = resolve30(root, "claude", ".claude.json");
+    const claudeJson = resolve31(operatorHome, ".claude.json");
+    const claudeTarget = resolve31(root, "claude", ".claude.json");
     const mcpServers = existsSync8(claudeJson) ? readClaudeUserScopeMcpServers(claudeJson) : void 0;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
       await writeIsolatedHarnessFile(claudeTarget, `${JSON.stringify({ mcpServers }, null, 2)}
@@ -39721,8 +39958,8 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
     console.warn("[body] operator MCP passthrough failed for claude:", error);
   }
   try {
-    const piJson = resolve30(operatorHome, PI_MCP_CONFIG.source);
-    const piTarget = resolve30(root, "pi", PI_MCP_CONFIG.target);
+    const piJson = resolve31(operatorHome, PI_MCP_CONFIG.source);
+    const piTarget = resolve31(root, "pi", PI_MCP_CONFIG.target);
     const mcpServers = existsSync8(piJson) ? localMcpServers(recordValue2(readJsonObject2(piJson)?.mcpServers) ?? {}) : void 0;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
       await writeIsolatedHarnessFile(piTarget, `${JSON.stringify({ mcpServers }, null, 2)}
@@ -39737,7 +39974,7 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
   }
   try {
     const settings2 = { permissions: { allow: ["WebSearch", "WebFetch"] } };
-    await writeIsolatedHarnessFile(resolve30(root, "claude", "settings.json"), `${JSON.stringify(settings2, null, 2)}
+    await writeIsolatedHarnessFile(resolve31(root, "claude", "settings.json"), `${JSON.stringify(settings2, null, 2)}
 `);
   } catch (error) {
     if (failClosed)
@@ -39751,7 +39988,7 @@ async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, fa
       httpIdleTimeoutMs: 3e5,
       retry: { enabled: true, maxRetries: 3, baseDelayMs: 2e3 }
     };
-    await writeIsolatedHarnessFile(resolve30(root, "pi", "settings.json"), `${JSON.stringify(settings2, null, 2)}
+    await writeIsolatedHarnessFile(resolve31(root, "pi", "settings.json"), `${JSON.stringify(settings2, null, 2)}
 `);
   }
 }
@@ -39771,7 +40008,7 @@ async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, fa
       const routes = routesFor(config.dir);
       if (Object.keys(routes).length === 0)
         continue;
-      const target = resolve30(root, config.dir, "config.toml");
+      const target = resolve31(root, config.dir, "config.toml");
       const existing = existsSync8(target) ? readFileSync10(target, "utf8") : void 0;
       const merged = mergeTomlHostRoutes(existing, routes);
       if (merged)
@@ -39780,9 +40017,9 @@ async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, fa
     if (appliesToHarness(agentKind, "goose")) {
       const routes = routesFor("goose");
       if (Object.keys(routes).length > 0) {
-        const gooseConfigDir = resolve30(root, "goose", "config");
+        const gooseConfigDir = resolve31(root, "goose", "config");
         await mkdir19(gooseConfigDir, { recursive: true, mode: 448 });
-        const target = resolve30(gooseConfigDir, "config.yaml");
+        const target = resolve31(gooseConfigDir, "config.yaml");
         const existing = existsSync8(target) ? readFileSync10(target, "utf8") : void 0;
         const merged = mergeGooseHostRoutes(existing, routes);
         if (merged)
@@ -39792,7 +40029,7 @@ async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, fa
     if (appliesToHarness(agentKind, "claude")) {
       const routes = routesFor("claude");
       if (Object.keys(routes).length > 0) {
-        const target = resolve30(root, "claude", ".claude.json");
+        const target = resolve31(root, "claude", ".claude.json");
         const parsed = existsSync8(target) ? readJsonObject2(target) : void 0;
         const merged = mergeJsonHostRoutes(recordValue2(parsed?.mcpServers), routes);
         if (merged && Object.keys(merged).length > 0) {
@@ -39804,7 +40041,7 @@ async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, fa
     if (appliesToHarness(agentKind, "pi")) {
       const routes = routesFor("pi");
       if (Object.keys(routes).length > 0) {
-        const target = resolve30(root, "pi", PI_MCP_CONFIG.target);
+        const target = resolve31(root, "pi", PI_MCP_CONFIG.target);
         const parsed = existsSync8(target) ? readJsonObject2(target) : void 0;
         const merged = mergeJsonHostRoutes(recordValue2(parsed?.mcpServers), routes);
         if (merged && Object.keys(merged).length > 0) {
@@ -39820,8 +40057,8 @@ async function applyGrantedHostRoutes(root, operatorHome, granted, agentKind, fa
   }
 }
 async function provisionPiCustomModelConfig(root, operatorHome, failClosed, openRouterRouting) {
-  const source = resolve30(operatorHome, PI_CUSTOM_MODEL_CONFIG.source);
-  const target = resolve30(root, "pi", PI_CUSTOM_MODEL_CONFIG.target);
+  const source = resolve31(operatorHome, PI_CUSTOM_MODEL_CONFIG.source);
+  const target = resolve31(root, "pi", PI_CUSTOM_MODEL_CONFIG.target);
   let decision2;
   if (openRouterRouting) {
     decision2 = await resolveOpenRouterRouting(openRouterRouting);
@@ -39845,7 +40082,7 @@ async function provisionPiCustomModelConfig(root, operatorHome, failClosed, open
     limits: decision2.limits ?? { maxTokens: OPENROUTER_MAX_OUTPUT_TOKENS }
   } : void 0;
   try {
-    const sourceStats = await lstat5(source).catch(() => void 0);
+    const sourceStats = await lstat6(source).catch(() => void 0);
     if (!sourceStats) {
       await writeIsolatedHarnessFile(target, `${JSON.stringify(withOpenRouterModelRouting({}, pin), null, 2)}
 `);
@@ -39935,19 +40172,19 @@ function mountedImportedMcpServerNames(input = {}) {
     const home = env.HOME ?? input.operatorHome ?? homedir14();
     const kind = input.agentKind;
     if (!kind || kind === "codex") {
-      addTomlMcpNames(names, resolve30(env.CODEX_HOME ?? resolve30(home, ".codex"), "config.toml"));
+      addTomlMcpNames(names, resolve31(env.CODEX_HOME ?? resolve31(home, ".codex"), "config.toml"));
     }
     if (!kind || kind === "grok") {
-      addTomlMcpNames(names, resolve30(env.GROK_HOME ?? resolve30(home, ".grok"), "config.toml"));
+      addTomlMcpNames(names, resolve31(env.GROK_HOME ?? resolve31(home, ".grok"), "config.toml"));
     }
     if (!kind || kind === "claude") {
-      addClaudeMcpNames(names, resolve30(env.CLAUDE_CONFIG_DIR ?? home, ".claude.json"));
+      addClaudeMcpNames(names, resolve31(env.CLAUDE_CONFIG_DIR ?? home, ".claude.json"));
     }
     if (!kind || kind === "goose") {
-      addGooseExtensionNames(names, env.GOOSE_PATH_ROOT ? resolve30(env.GOOSE_PATH_ROOT, "config/config.yaml") : resolve30(home, ".config/goose/config.yaml"));
+      addGooseExtensionNames(names, env.GOOSE_PATH_ROOT ? resolve31(env.GOOSE_PATH_ROOT, "config/config.yaml") : resolve31(home, ".config/goose/config.yaml"));
     }
     if (!kind || kind === "pi") {
-      addClaudeMcpNames(names, resolve30(env.PI_CODING_AGENT_DIR ?? resolve30(home, ".pi/agent"), PI_MCP_CONFIG.target));
+      addClaudeMcpNames(names, resolve31(env.PI_CODING_AGENT_DIR ?? resolve31(home, ".pi/agent"), PI_MCP_CONFIG.target));
     }
   } else {
     collectImportedMcpNames(input.operatorHome ?? homedir14(), names, input.agentKind);
@@ -39967,17 +40204,17 @@ function hostImportedMcpDeclarations(input = {}) {
     }
   };
   if (!kind || kind === "codex")
-    add(readTomlMcpServers(resolve30(operatorHome, ".codex/config.toml")));
+    add(readTomlMcpServers(resolve31(operatorHome, ".codex/config.toml")));
   if (!kind || kind === "grok")
-    add(readTomlMcpServers(resolve30(operatorHome, ".grok/config.toml")));
+    add(readTomlMcpServers(resolve31(operatorHome, ".grok/config.toml")));
   if (!kind || kind === "claude") {
-    add(recordValue2(readJsonObject2(resolve30(operatorHome, ".claude.json"))?.mcpServers));
+    add(recordValue2(readJsonObject2(resolve31(operatorHome, ".claude.json"))?.mcpServers));
   }
   if (!kind || kind === "goose") {
-    add(readGooseExtensions(resolve30(operatorHome, ".config/goose/config.yaml")));
+    add(readGooseExtensions(resolve31(operatorHome, ".config/goose/config.yaml")));
   }
   if (!kind || kind === "pi") {
-    add(recordValue2(readJsonObject2(resolve30(operatorHome, PI_MCP_CONFIG.source))?.mcpServers));
+    add(recordValue2(readJsonObject2(resolve31(operatorHome, PI_MCP_CONFIG.source))?.mcpServers));
   }
   return declarations;
 }
@@ -40009,19 +40246,19 @@ function expectedMountedImportedMcpServerNames(input) {
 }
 function collectImportedMcpNames(operatorHome, names, kind) {
   if (!kind || kind === "codex") {
-    addLocalMcpNames(names, readTomlMcpServers(resolve30(operatorHome, ".codex/config.toml")));
+    addLocalMcpNames(names, readTomlMcpServers(resolve31(operatorHome, ".codex/config.toml")));
   }
   if (!kind || kind === "grok") {
-    addLocalMcpNames(names, readTomlMcpServers(resolve30(operatorHome, ".grok/config.toml")));
+    addLocalMcpNames(names, readTomlMcpServers(resolve31(operatorHome, ".grok/config.toml")));
   }
   if (!kind || kind === "claude") {
-    addLocalMcpNames(names, recordValue2(readJsonObject2(resolve30(operatorHome, ".claude.json"))?.mcpServers));
+    addLocalMcpNames(names, recordValue2(readJsonObject2(resolve31(operatorHome, ".claude.json"))?.mcpServers));
   }
   if (!kind || kind === "goose") {
-    addLocalMcpNames(names, readGooseExtensions(resolve30(operatorHome, ".config/goose/config.yaml")));
+    addLocalMcpNames(names, readGooseExtensions(resolve31(operatorHome, ".config/goose/config.yaml")));
   }
   if (!kind || kind === "pi") {
-    addLocalMcpNames(names, recordValue2(readJsonObject2(resolve30(operatorHome, PI_MCP_CONFIG.source))?.mcpServers));
+    addLocalMcpNames(names, recordValue2(readJsonObject2(resolve31(operatorHome, PI_MCP_CONFIG.source))?.mcpServers));
   }
 }
 function addLocalMcpNames(names, servers) {
@@ -40093,19 +40330,19 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, op
   const plan = await planManagedSkills(managedSkills, sharedSkills, optionalShares);
   if (await materializedSkillManifest(target) === plan.manifest)
     return;
-  const staged = resolve30(parent, `.skills.${process.pid}.${randomUUID13()}.tmp`);
+  const staged = resolve31(parent, `.skills.${process.pid}.${randomUUID13()}.tmp`);
   await mkdir19(staged, { mode: 448 });
   try {
     for (const entry of plan.entries) {
       if (entry.kind === "managed") {
-        const skillDir = resolve30(staged, entry.name);
+        const skillDir = resolve31(staged, entry.name);
         await mkdir19(skillDir, { recursive: true });
-        await writeIsolatedHarnessFile(resolve30(skillDir, "SKILL.md"), entry.content);
+        await writeIsolatedHarnessFile(resolve31(skillDir, "SKILL.md"), entry.content);
       } else {
-        await copySafeSkillTree(entry.source, resolve30(staged, entry.name), entry.source);
+        await copySafeSkillTree(entry.source, resolve31(staged, entry.name), entry.source);
       }
     }
-    const existing = await lstat5(target).catch(() => void 0);
+    const existing = await lstat6(target).catch(() => void 0);
     if (existing)
       await rm14(target, { recursive: existing.isDirectory(), force: true });
     await rename10(staged, target);
@@ -40130,7 +40367,7 @@ async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
       const tree = [];
       await walkSafeSkillTree(shared.source, shared.source, {
         directory: async (rel) => void tree.push(`d ${join15(shared.name, rel)}`),
-        file: async (rel, realPath) => void tree.push(`f ${join15(shared.name, rel)} ${sha2563(await readFile26(realPath))}`)
+        file: async (rel, realPath) => void tree.push(`f ${join15(shared.name, rel)} ${sha2563(await readFile27(realPath))}`)
       });
       entries.push({ kind: "shared", name: shared.name, source: shared.source });
       lines.push(...tree);
@@ -40143,15 +40380,15 @@ async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
   return { entries, manifest: lines.sort().join("\n") };
 }
 async function materializedSkillManifest(target) {
-  const stats = await lstat5(target).catch(() => void 0);
+  const stats = await lstat6(target).catch(() => void 0);
   if (!stats?.isDirectory() || stats.isSymbolicLink())
     return void 0;
   const lines = [];
   const visit = async (directory, prefix) => {
-    for (const entry of await readdir8(directory)) {
-      const path = resolve30(directory, entry);
+    for (const entry of await readdir9(directory)) {
+      const path = resolve31(directory, entry);
       const rel = prefix ? join15(prefix, entry) : entry;
-      const entryStats = await lstat5(path);
+      const entryStats = await lstat6(path);
       if (entryStats.isSymbolicLink())
         return false;
       if (entryStats.isDirectory()) {
@@ -40162,7 +40399,7 @@ async function materializedSkillManifest(target) {
       }
       if (!entryStats.isFile() || entryStats.nlink !== 1)
         return false;
-      lines.push(`f ${rel} ${sha2563(await readFile26(path))}`);
+      lines.push(`f ${rel} ${sha2563(await readFile27(path))}`);
     }
     return true;
   };
@@ -40184,16 +40421,16 @@ async function resolveSharedSkillSources(operatorHome, names) {
   const resolved = [];
   const skipped = [];
   for (const relativeRoot of OPERATOR_SKILL_SOURCE_DIRS) {
-    const sourceRoot = resolve30(operatorHome, relativeRoot);
-    const rootStats = await lstat5(sourceRoot).catch(() => void 0);
+    const sourceRoot = resolve31(operatorHome, relativeRoot);
+    const rootStats = await lstat6(sourceRoot).catch(() => void 0);
     if (!rootStats?.isDirectory() || rootStats.isSymbolicLink())
       continue;
-    for (const entry of await readdir8(sourceRoot)) {
+    for (const entry of await readdir9(sourceRoot)) {
       if (!isSharedSkillName(entry) || seen.has(entry))
         continue;
-      const candidate = resolve30(sourceRoot, entry);
+      const candidate = resolve31(sourceRoot, entry);
       try {
-        const candidateStats = await lstat5(candidate);
+        const candidateStats = await lstat6(candidate);
         if (candidateStats.isSymbolicLink()) {
           const reason = await realpath2(candidate).then(() => "symlinked directory", (error) => isMissingPathError(error) ? "dangling symlink" : "symlinked directory");
           skipped.push({
@@ -40207,8 +40444,8 @@ async function resolveSharedSkillSources(operatorHome, names) {
           continue;
         }
         assertContained(sourceRoot, candidate);
-        const skillMd = resolve30(candidate, "SKILL.md");
-        const skillStats = await lstat5(skillMd).catch((error) => {
+        const skillMd = resolve31(candidate, "SKILL.md");
+        const skillStats = await lstat6(skillMd).catch((error) => {
           if (isMissingPathError(error)) {
             skipped.push({ path: candidate, reason: "missing SKILL.md" });
             return void 0;
@@ -40259,10 +40496,10 @@ async function resolveExplicitSkillSources(operatorHome, names) {
   for (const name of unique) {
     const matches = [];
     for (const relativeRoot of OPERATOR_SKILL_SOURCE_DIRS) {
-      const sourceRoot = resolve30(operatorHome, relativeRoot);
-      const candidate = resolve30(sourceRoot, name);
-      const rootStats = await lstat5(sourceRoot).catch(() => void 0);
-      const candidateStats = await lstat5(candidate).catch(() => void 0);
+      const sourceRoot = resolve31(operatorHome, relativeRoot);
+      const candidate = resolve31(sourceRoot, name);
+      const rootStats = await lstat6(sourceRoot).catch(() => void 0);
+      const candidateStats = await lstat6(candidate).catch(() => void 0);
       if (!candidateStats)
         continue;
       if (!rootStats?.isDirectory() || rootStats.isSymbolicLink()) {
@@ -40277,8 +40514,8 @@ async function resolveExplicitSkillSources(operatorHome, names) {
     if (matches.length !== 1) {
       throw new Error(matches.length === 0 ? `shared skill is unavailable: ${name}` : `shared skill source is ambiguous: ${name}`);
     }
-    const skillMd = resolve30(matches[0], "SKILL.md");
-    const skillStats = await lstat5(skillMd).catch(() => void 0);
+    const skillMd = resolve31(matches[0], "SKILL.md");
+    const skillStats = await lstat6(skillMd).catch(() => void 0);
     if (!skillStats?.isFile() || skillStats.isSymbolicLink() || skillStats.nlink !== 1) {
       throw new Error(`shared skill requires an ordinary SKILL.md: ${name}`);
     }
@@ -40288,13 +40525,13 @@ async function resolveExplicitSkillSources(operatorHome, names) {
 }
 function assertContained(root, candidate) {
   const rel = relative2(root, candidate);
-  if (rel === ".." || rel.startsWith(`..${sep2}`) || resolve30(root, rel) !== resolve30(candidate)) {
+  if (rel === ".." || rel.startsWith(`..${sep2}`) || resolve31(root, rel) !== resolve31(candidate)) {
     throw new Error(`path escapes the agent skill boundary: ${candidate}`);
   }
 }
 async function assertRealContainedDirectory(path, root) {
   assertContained(root, path);
-  const stats = await lstat5(path);
+  const stats = await lstat6(path);
   if (!stats.isDirectory() || stats.isSymbolicLink()) {
     throw new AgentHomeSecurityError(`agent skill destination is not an ordinary directory: ${path}`);
   }
@@ -40303,11 +40540,11 @@ var BLOCKED_SHARED_FILENAMES = /^(?:\.env(?:\..*)?|auth\.json|\.credentials\.jso
 async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
   assertContained(sourceRoot, source);
   const resolvedSource = await realpath2(source);
-  if (resolvedSource !== resolve30(source)) {
+  if (resolvedSource !== resolve31(source)) {
     throw new Error(`shared skill path resolves through a link: ${source}`);
   }
   assertContained(sourceRoot, resolvedSource);
-  const stats = await lstat5(resolvedSource);
+  const stats = await lstat6(resolvedSource);
   if (stats.isSymbolicLink())
     throw new Error(`shared skill contains a symlink: ${source}`);
   if (BLOCKED_SHARED_FILENAMES.test(basename8(source))) {
@@ -40315,10 +40552,10 @@ async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
   }
   if (stats.isDirectory()) {
     await visitor.directory(rel);
-    for (const entry of await readdir8(resolvedSource)) {
+    for (const entry of await readdir9(resolvedSource)) {
       if (entry === "." || entry === "..")
         throw new Error("invalid shared skill entry");
-      await walkSafeSkillTree(resolve30(source, entry), sourceRoot, visitor, rel ? join15(rel, entry) : entry);
+      await walkSafeSkillTree(resolve31(source, entry), sourceRoot, visitor, rel ? join15(rel, entry) : entry);
     }
     return;
   }
@@ -40330,10 +40567,10 @@ async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
 async function copySafeSkillTree(source, target, sourceRoot) {
   await walkSafeSkillTree(source, sourceRoot, {
     directory: async (rel) => {
-      await mkdir19(resolve30(target, rel), { mode: 448 });
+      await mkdir19(resolve31(target, rel), { mode: 448 });
     },
     file: async (rel, realPath) => {
-      const destination = resolve30(target, rel);
+      const destination = resolve31(target, rel);
       await copyFile(realPath, destination);
       await chmod8(destination, 384);
     }
@@ -40341,11 +40578,11 @@ async function copySafeSkillTree(source, target, sourceRoot) {
 }
 async function writeIsolatedHarnessFile(path, content) {
   const parent = dirname22(path);
-  const parentStats = await lstat5(parent);
+  const parentStats = await lstat6(parent);
   if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
     throw new Error(`isolated harness parent is not a real directory: ${parent}`);
   }
-  const temporary = resolve30(parent, `.${basename8(path)}.${process.pid}.${randomUUID13()}.tmp`);
+  const temporary = resolve31(parent, `.${basename8(path)}.${process.pid}.${randomUUID13()}.tmp`);
   try {
     await writeFile17(temporary, content, { mode: 384, flag: "wx" });
     await chmod8(temporary, 384);
@@ -40355,24 +40592,24 @@ async function writeIsolatedHarnessFile(path, content) {
   }
 }
 function roomSessionTmpDir(root, base = "/tmp") {
-  const hash = createHash13("sha256").update(resolve30(root)).digest("hex").slice(0, 12);
+  const hash = createHash13("sha256").update(resolve31(root)).digest("hex").slice(0, 12);
   return join15(base, `beeline-${hash}`);
 }
 function roomAgentHomeEnv(root) {
-  const resolved = resolve30(root);
+  const resolved = resolve31(root);
   return {
-    HOME: resolve30(resolved, "user"),
-    CLAUDE_CONFIG_DIR: resolve30(resolved, "claude"),
-    CODEX_HOME: resolve30(resolved, "codex"),
-    GOOSE_PATH_ROOT: resolve30(resolved, "goose"),
-    GROK_HOME: resolve30(resolved, "grok"),
-    CURSOR_HOME: resolve30(resolved, "cursor"),
-    OPENCODE_CONFIG_DIR: resolve30(resolved, "opencode"),
-    PI_CODING_AGENT_DIR: resolve30(resolved, "pi"),
-    XDG_CONFIG_HOME: resolve30(resolved, "user/.config"),
-    XDG_DATA_HOME: resolve30(resolved, "user/.local/share"),
-    XDG_STATE_HOME: resolve30(resolved, "state"),
-    XDG_CACHE_HOME: resolve30(resolved, "cache"),
+    HOME: resolve31(resolved, "user"),
+    CLAUDE_CONFIG_DIR: resolve31(resolved, "claude"),
+    CODEX_HOME: resolve31(resolved, "codex"),
+    GOOSE_PATH_ROOT: resolve31(resolved, "goose"),
+    GROK_HOME: resolve31(resolved, "grok"),
+    CURSOR_HOME: resolve31(resolved, "cursor"),
+    OPENCODE_CONFIG_DIR: resolve31(resolved, "opencode"),
+    PI_CODING_AGENT_DIR: resolve31(resolved, "pi"),
+    XDG_CONFIG_HOME: resolve31(resolved, "user/.config"),
+    XDG_DATA_HOME: resolve31(resolved, "user/.local/share"),
+    XDG_STATE_HOME: resolve31(resolved, "state"),
+    XDG_CACHE_HOME: resolve31(resolved, "cache"),
     TMPDIR: roomSessionTmpDir(resolved)
   };
 }
@@ -40395,10 +40632,10 @@ function harnessStateDirsFromEnv(env) {
   for (const name of HARNESS_STATE_ENV_VARS) {
     const value = env[name];
     if (value)
-      stateDirs.push(resolve30(value));
+      stateDirs.push(resolve31(value));
   }
   const tmp = env.TMPDIR;
-  return { stateDirs, ...tmp ? { tmpDir: resolve30(tmp) } : {} };
+  return { stateDirs, ...tmp ? { tmpDir: resolve31(tmp) } : {} };
 }
 
 // apps/body/dist/agent-command-catalog.js
@@ -41038,12 +41275,12 @@ function mountedMcpSet(servers) {
 }
 
 // apps/body/dist/corner-prepare-script.js
-import { readFile as readFile27 } from "node:fs/promises";
-import { resolve as resolve31 } from "node:path";
+import { readFile as readFile28 } from "node:fs/promises";
+import { resolve as resolve32 } from "node:path";
 var CORNER_PREPARE_SCRIPT = "corner:prepare";
 async function hasCornerPrepareScript(worktreePath) {
   try {
-    const parsed = JSON.parse(await readFile27(resolve31(worktreePath, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile28(resolve32(worktreePath, "package.json"), "utf8"));
     return typeof parsed.scripts?.[CORNER_PREPARE_SCRIPT] === "string";
   } catch {
     return false;
@@ -41052,9 +41289,9 @@ async function hasCornerPrepareScript(worktreePath) {
 
 // apps/body/dist/pi-mcp-bridge.js
 import { execFile as execFile13 } from "node:child_process";
-import { mkdtemp as mkdtemp2, mkdir as mkdir21, readFile as readFile28, rm as rm15, unlink as unlink7 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, mkdir as mkdir21, readFile as readFile29, rm as rm15, unlink as unlink7 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { resolve as resolve32 } from "node:path";
+import { resolve as resolve33 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 var PI_MCP_BRIDGE_FILENAME = "beeline-mcp-bridge.js";
 var execFileAsync8 = promisify8(execFile13);
@@ -41065,7 +41302,7 @@ async function piHasNativeMcp(command, env) {
   let probe = nativeMcpProbes.get(cacheKey);
   if (!probe) {
     probe = (async () => {
-      const home = await mkdtemp2(resolve32(tmpdir5(), "beeline-pi-mcp-probe-"));
+      const home = await mkdtemp2(resolve33(tmpdir5(), "beeline-pi-mcp-probe-"));
       try {
         const { stdout: stdout6 } = await execFileAsync8(command, ["mcp", "list", "--json"], {
           cwd: home,
@@ -41086,7 +41323,7 @@ async function piHasNativeMcp(command, env) {
 }
 async function isolatedPiConfig(piHome) {
   try {
-    const parsed = JSON.parse(await readFile28(resolve32(piHome, "mcp.json"), "utf8"));
+    const parsed = JSON.parse(await readFile29(resolve33(piHome, "mcp.json"), "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch (error) {
     if (error.code !== "ENOENT")
@@ -41140,8 +41377,8 @@ async function installPiMcpBridge(input) {
     return void 0;
   if (!input.piHome)
     return void 0;
-  const directory = resolve32(input.piHome, "extensions");
-  const path = resolve32(directory, PI_MCP_BRIDGE_FILENAME);
+  const directory = resolve33(input.piHome, "extensions");
+  const path = resolve33(directory, PI_MCP_BRIDGE_FILENAME);
   try {
     const config = await isolatedPiConfig(input.piHome);
     const nativeMcp = input.nativeMcp ?? await piHasNativeMcp(input.piCommand ?? "pi", input.agentEnv);
@@ -41154,13 +41391,13 @@ async function installPiMcpBridge(input) {
           env: Object.fromEntries((server.env ?? []).map((entry) => [entry.name, entry.value])),
           exposure: "direct"
         };
-      await writeIsolatedHarnessFile(resolve32(input.piHome, "mcp.json"), `${JSON.stringify({ ...config, mcpServers: mcpServers2 }, null, 2)}
+      await writeIsolatedHarnessFile(resolve33(input.piHome, "mcp.json"), `${JSON.stringify({ ...config, mcpServers: mcpServers2 }, null, 2)}
 `);
       await unlink7(path).catch((error) => {
         if (error.code !== "ENOENT")
           throw error;
       });
-      return resolve32(input.piHome, "mcp.json");
+      return resolve33(input.piHome, "mcp.json");
     }
     const servers = [...input.servers, ...importedStdioServers(config, input.servers)];
     if (!servers.length)
@@ -41173,7 +41410,7 @@ async function installPiMcpBridge(input) {
         env: Object.fromEntries((server.env ?? []).map((entry) => [entry.name, entry.value])),
         enabled: false
       };
-    await writeIsolatedHarnessFile(resolve32(input.piHome, "mcp.json"), `${JSON.stringify({ ...config, mcpServers }, null, 2)}
+    await writeIsolatedHarnessFile(resolve33(input.piHome, "mcp.json"), `${JSON.stringify({ ...config, mcpServers }, null, 2)}
 `);
     await mkdir21(directory, { recursive: true, mode: 448 });
     await writeIsolatedHarnessFile(path, piMcpBridgeSource(servers));
@@ -41365,8 +41602,8 @@ export default async function (pi) {
 
 // apps/body/dist/corner-branch-sync.js
 import { execFile as execFile14 } from "node:child_process";
-import { access as access2, readFile as readFile29 } from "node:fs/promises";
-import { resolve as resolve33 } from "node:path";
+import { access as access2, readFile as readFile30 } from "node:fs/promises";
+import { resolve as resolve34 } from "node:path";
 var CORNER_GIT_SYNC_TIMEOUT_MS = 12e4;
 var CORNER_GIT_SYNC_KILL_GRACE_MS = 1e3;
 var CornerGitSyncInterruptedError = class extends Error {
@@ -41380,7 +41617,7 @@ async function syncCornerBranch(input) {
     try {
       if (signal.aborted)
         throw interrupted();
-      return await new Promise((resolve52, reject) => {
+      return await new Promise((resolve53, reject) => {
         let killTimer;
         let stdout6 = "";
         let failure = null;
@@ -41414,19 +41651,19 @@ async function syncCornerBranch(input) {
             else if (failure)
               reject(failure);
             else
-              resolve52(stdout6);
+              resolve53(stdout6);
           });
         else
-          input.git(args).then(resolve52, reject).finally(cleanup2);
+          input.git(args).then(resolve53, reject).finally(cleanup2);
       });
     } finally {
       clearTimeout(timer);
     }
   };
-  const marker = await readFile29(resolve33(input.worktreePath, ".git"), "utf8").catch(() => "");
-  const gitDir = resolve33(input.worktreePath, marker.startsWith("gitdir: ") ? marker.slice(8).trim() : ".git");
+  const marker = await readFile30(resolve34(input.worktreePath, ".git"), "utf8").catch(() => "");
+  const gitDir = resolve34(input.worktreePath, marker.startsWith("gitdir: ") ? marker.slice(8).trim() : ".git");
   for (const directory of ["rebase-merge", "rebase-apply"]) {
-    if (await access2(resolve33(gitDir, directory)).then(() => true, () => false))
+    if (await access2(resolve34(gitDir, directory)).then(() => true, () => false))
       await git2(["rebase", "--abort"], true);
   }
   const remoteRef = `refs/remotes/origin/${input.featureBranch}`;
@@ -41474,7 +41711,7 @@ async function contains(git2, head, ancestor) {
 }
 
 // apps/body/dist/room-session.js
-import { resolve as resolve34 } from "node:path";
+import { resolve as resolve35 } from "node:path";
 import { homedir as homedir15 } from "node:os";
 
 // apps/body/dist/read-only-policy.js
@@ -41716,22 +41953,22 @@ function readOnlyMcpServer(config, cwd, agentMemoryDir) {
     command: config.readonlyMcpCommand,
     args: [...config.readonlyMcpArgs ?? []],
     env: [
-      { name: "BEELINE_READONLY_ROOT", value: resolve34(cwd) },
+      { name: "BEELINE_READONLY_ROOT", value: resolve35(cwd) },
       ...config.agentHomeRoot ? [
         {
           name: "BEELINE_READONLY_AGENT_SKILLS_ROOT",
-          value: resolve34(config.agentHomeRoot, skillDir, "skills")
+          value: resolve35(config.agentHomeRoot, skillDir, "skills")
         }
       ] : [],
-      ...agentMemoryDir ? [{ name: "BEELINE_READONLY_AGENT_MEMORY_ROOT", value: resolve34(agentMemoryDir) }] : []
+      ...agentMemoryDir ? [{ name: "BEELINE_READONLY_AGENT_MEMORY_ROOT", value: resolve35(agentMemoryDir) }] : []
     ]
   };
 }
 
 // apps/body/dist/scratch-lifecycle.js
 import { execFile as execFile15 } from "node:child_process";
-import { lstat as lstat6, readdir as readdir9, rmdir as rmdir2, rm as rm16, stat as stat10, unlink as unlink8 } from "node:fs/promises";
-import { join as join17, resolve as resolve35 } from "node:path";
+import { lstat as lstat7, readdir as readdir10, rmdir as rmdir2, rm as rm16, stat as stat10, unlink as unlink8 } from "node:fs/promises";
+import { join as join17, resolve as resolve36 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 var execFileAsync9 = promisify9(execFile15);
 var CORNER_SCRATCH_BUDGET_BYTES = 5 * 1024 ** 3;
@@ -41739,7 +41976,7 @@ var CORNER_SCRATCH_TTL_MS = 14 * 24 * 60 * 6e4;
 var SHARED_MODEL_CACHE_BUDGET_BYTES = 32 * 1024 ** 3;
 var MODEL_CACHE_IDLE_MS = 24 * 60 * 6e4;
 async function allocatedDirectoryBytes(path) {
-  if (!await lstat6(path).catch(() => void 0))
+  if (!await lstat7(path).catch(() => void 0))
     return 0;
   const output = await execFileAsync9("du", ["-s", "-B1", "--", path], {
     maxBuffer: 1024 * 1024
@@ -41761,11 +41998,11 @@ async function sweepStaleCornerScratch(root, now2 = Date.now(), ttlMs = CORNER_S
   let files = 0;
   let bytes = 0;
   const visit = async (dir, top) => {
-    for (const entry of await readdir9(dir, { withFileTypes: true }).catch(() => [])) {
+    for (const entry of await readdir10(dir, { withFileTypes: true }).catch(() => [])) {
       if (top && (entry.name === "agent-home" || entry.name === "agent-private" || entry.name === ".git"))
         continue;
       const path = join17(dir, entry.name);
-      const info = await lstat6(path).catch(() => void 0);
+      const info = await lstat7(path).catch(() => void 0);
       if (!info || info.isSymbolicLink())
         continue;
       if (info.isDirectory()) {
@@ -41779,8 +42016,8 @@ async function sweepStaleCornerScratch(root, now2 = Date.now(), ttlMs = CORNER_S
       }
     }
   };
-  if ((await lstat6(root).catch(() => void 0))?.isDirectory())
-    await visit(resolve35(root), true);
+  if ((await lstat7(root).catch(() => void 0))?.isDirectory())
+    await visit(resolve36(root), true);
   return { files, bytes };
 }
 async function pruneSharedModelCache(root, now2 = Date.now(), budget = SHARED_MODEL_CACHE_BUDGET_BYTES) {
@@ -41789,7 +42026,7 @@ async function pruneSharedModelCache(root, now2 = Date.now(), budget = SHARED_MO
     return [];
   const candidates = [];
   for (const parent of [join17(root, "hub"), root]) {
-    for (const entry of await readdir9(parent, { withFileTypes: true }).catch(() => [])) {
+    for (const entry of await readdir10(parent, { withFileTypes: true }).catch(() => [])) {
       const eligible = parent === root ? entry.name === "xet" : /^(?:models|datasets|spaces)--/.test(entry.name);
       if (!eligible || !entry.isDirectory())
         continue;
@@ -41861,15 +42098,15 @@ async function awaitInstitutionalContext(fetch2, log2 = console.warn, budgetMs =
 
 // apps/body/dist/codegraph.js
 import { execFile as execFile16 } from "node:child_process";
-import { access as access3, appendFile, mkdir as mkdir22, readFile as readFile30 } from "node:fs/promises";
-import { dirname as dirname23, isAbsolute as isAbsolute4, resolve as resolve36 } from "node:path";
+import { access as access3, appendFile, mkdir as mkdir22, readFile as readFile31 } from "node:fs/promises";
+import { dirname as dirname23, isAbsolute as isAbsolute4, resolve as resolve37 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync10 = promisify10(execFile16);
 var CODEGRAPH_MCP_SERVER_NAME = "codegraph";
 var CODEGRAPH_INDEX_PATH = ".codegraph/codegraph.db";
 var CODEGRAPH_PREPARE_TIMEOUT_MS = 12e4;
 function codegraphIndexDirectory(cwd) {
-  return resolve36(cwd, dirname23(CODEGRAPH_INDEX_PATH));
+  return resolve37(cwd, dirname23(CODEGRAPH_INDEX_PATH));
 }
 function codegraphMcpServer(config, cwd, options) {
   if (!config.codegraphCommand)
@@ -41877,7 +42114,7 @@ function codegraphMcpServer(config, cwd, options) {
   return {
     name: CODEGRAPH_MCP_SERVER_NAME,
     command: config.codegraphCommand,
-    args: ["serve", "--mcp", "--path", resolve36(cwd), ...options.readonly ? ["--no-watch"] : []],
+    args: ["serve", "--mcp", "--path", resolve37(cwd), ...options.readonly ? ["--no-watch"] : []],
     env: [
       { name: "CODEGRAPH_TELEMETRY", value: "0" },
       // One MCP child per harness session is easier to contain than a daemon
@@ -41895,7 +42132,7 @@ async function isGitWorktree(cwd) {
       cwd,
       timeout: 1e4
     });
-    return resolve36(stdout6.trim()) === resolve36(cwd);
+    return resolve37(stdout6.trim()) === resolve37(cwd);
   } catch {
     return false;
   }
@@ -41909,9 +42146,9 @@ async function excludeIndexFromGitStatus(cwd) {
     const gitPath = stdout6.trim();
     if (!gitPath)
       return;
-    const path = isAbsolute4(gitPath) ? gitPath : resolve36(cwd, gitPath);
+    const path = isAbsolute4(gitPath) ? gitPath : resolve37(cwd, gitPath);
     await mkdir22(dirname23(path), { recursive: true });
-    const existing = await readFile30(path, "utf8").catch(() => "");
+    const existing = await readFile31(path, "utf8").catch(() => "");
     if (existing.split("\n").includes(".codegraph/"))
       return;
     await appendFile(path, `${existing && !existing.endsWith("\n") ? "\n" : ""}.codegraph/
@@ -41924,7 +42161,7 @@ async function prepareCodegraphIndex(config, cwd) {
   if (!command || !await isGitWorktree(cwd))
     return false;
   await excludeIndexFromGitStatus(cwd);
-  const indexPath = resolve36(cwd, CODEGRAPH_INDEX_PATH);
+  const indexPath = resolve37(cwd, CODEGRAPH_INDEX_PATH);
   const indexed = await access3(indexPath).then(() => true, () => false);
   const args = indexed ? ["sync", "--quiet", cwd] : ["init", "--yes", cwd];
   try {
@@ -42744,8 +42981,8 @@ function assembleTurnPrompt(context) {
 }
 
 // apps/body/dist/turn-trace.js
-import { appendFile as appendFile2, mkdir as mkdir23, readdir as readdir10, rm as rm17 } from "node:fs/promises";
-import { resolve as resolve37 } from "node:path";
+import { appendFile as appendFile2, mkdir as mkdir23, readdir as readdir11, rm as rm17 } from "node:fs/promises";
+import { resolve as resolve38 } from "node:path";
 import { performance as performance3 } from "node:perf_hooks";
 var TURN_PHASES = [
   /** Enqueued on `SessionScheduler` until this turn holds a slot. A capacity wait lives here. */
@@ -43034,7 +43271,7 @@ function formatTurnTraceLine(record5) {
   return [head, ...record5.attempts.map((attempt) => formatTurnAttempt(attempt))].join("\n  ");
 }
 function turnTraceDirectory(runtimeDir) {
-  return resolve37(runtimeDir, "turn-traces");
+  return resolve38(runtimeDir, "turn-traces");
 }
 var TURN_TRACE_RETENTION_DAYS = 7;
 function traceFileName(date) {
@@ -43051,7 +43288,7 @@ var TurnTraceFile = class {
     this.options = options;
   }
   path(now2 = (this.options.clock ?? (() => /* @__PURE__ */ new Date()))()) {
-    return resolve37(this.directory, traceFileName(now2));
+    return resolve38(this.directory, traceFileName(now2));
   }
   write(record5) {
     this.tail = this.tail.catch(() => void 0).then(async () => {
@@ -43074,8 +43311,8 @@ var TurnTraceFile = class {
       return;
     this.prunedDay = day;
     const cutoff = traceFileName(new Date(now2.getTime() - TURN_TRACE_RETENTION_DAYS * 864e5));
-    const names = await readdir10(this.directory).catch(() => []);
-    await Promise.all(names.filter((name) => /^turns-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name < cutoff).map((name) => rm17(resolve37(this.directory, name), { force: true })));
+    const names = await readdir11(this.directory).catch(() => []);
+    await Promise.all(names.filter((name) => /^turns-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name < cutoff).map((name) => rm17(resolve38(this.directory, name), { force: true })));
   }
 };
 
@@ -44099,8 +44336,8 @@ var MonolithRoomTurnLoop = class {
         let timer;
         const stats = statsPromise && remaining > 0 ? await Promise.race([
           statsPromise,
-          new Promise((resolve52) => {
-            timer = setTimeout(() => resolve52(void 0), remaining);
+          new Promise((resolve53) => {
+            timer = setTimeout(() => resolve53(void 0), remaining);
           })
         ]).finally(() => {
           if (timer)
@@ -44517,9 +44754,9 @@ function roomMessagePrompt(author, body, attachments, delivered, harnessAcceptsI
 
 // apps/body/dist/corner-github-auth.js
 import { chmod as chmod9, mkdir as mkdir25, writeFile as writeFile20 } from "node:fs/promises";
-import { delimiter as delimiter3, resolve as resolve38 } from "node:path";
+import { delimiter as delimiter3, resolve as resolve39 } from "node:path";
 async function installCornerGitHubWrappers(input) {
-  const bin = resolve38(input.root, "beeline-github-bin");
+  const bin = resolve39(input.root, "beeline-github-bin");
   await mkdir25(bin, { recursive: true, mode: 448 });
   const common = {
     node: process.execPath,
@@ -44531,13 +44768,13 @@ async function installCornerGitHubWrappers(input) {
     gitCommand: input.gitBinary,
     originUrl: input.originUrl ?? ""
   };
-  await writeLauncher(resolve38(bin, "git"), {
+  await writeLauncher(resolve39(bin, "git"), {
     ...common,
     command: input.gitBinary,
     launcher: "git",
     restFallback: false
   });
-  await writeLauncher(resolve38(bin, "gh"), {
+  await writeLauncher(resolve39(bin, "gh"), {
     ...common,
     command: input.ghBinary ?? "",
     launcher: "gh",
@@ -44991,32 +45228,32 @@ function agentGitIdentityEnv(agent) {
 // apps/body/dist/warm-node-modules.js
 import { createHash as createHash15, randomUUID as randomUUID14 } from "node:crypto";
 import { constants as fsConstants3 } from "node:fs";
-import { chmod as chmod10, copyFile as copyFile2, link, lstat as lstat7, mkdir as mkdir26, readdir as readdir11, readFile as readFile31, readlink as readlink2, rename as rename11, rm as rm18, stat as stat11, symlink as symlink3, utimes } from "node:fs/promises";
-import { dirname as dirname25, join as join19, resolve as resolve39 } from "node:path";
+import { chmod as chmod10, copyFile as copyFile2, link, lstat as lstat8, mkdir as mkdir26, readdir as readdir12, readFile as readFile32, readlink as readlink2, rename as rename11, rm as rm18, stat as stat11, symlink as symlink3, utimes } from "node:fs/promises";
+import { dirname as dirname25, join as join19, resolve as resolve40 } from "node:path";
 var STORE_FORMAT = "v1";
 var STAGING_PREFIX = ".beeline-warm-";
 var STAGING_SWEEP_MS = 24 * 60 * 60 * 1e3;
 var WARM_STORE_MAX_ENTRIES = 3;
 function sharedNpmCacheDir(supervisorRoot2) {
-  return resolve39(supervisorRoot2, "beeline", "npm-cache");
+  return resolve40(supervisorRoot2, "beeline", "npm-cache");
 }
 function sharedPnpmStoreDir(supervisorRoot2) {
-  return resolve39(supervisorRoot2, "beeline", "pnpm-store");
+  return resolve40(supervisorRoot2, "beeline", "pnpm-store");
 }
 function sharedTurboCacheDir(supervisorRoot2) {
-  return resolve39(supervisorRoot2, "beeline", "turbo-cache");
+  return resolve40(supervisorRoot2, "beeline", "turbo-cache");
 }
 function warmNodeModulesStoreDir(supervisorRoot2) {
-  return resolve39(supervisorRoot2, "beeline", "node-modules");
+  return resolve40(supervisorRoot2, "beeline", "node-modules");
 }
 function mobileNodeModulesStoreDir(supervisorRoot2) {
-  return resolve39(supervisorRoot2, "beeline", "node-modules-mobile");
+  return resolve40(supervisorRoot2, "beeline", "node-modules-mobile");
 }
 function isPlanRefusal(value) {
   return "failure" in value;
 }
 async function readWarmPlan(worktreePath) {
-  const lockfile = await readFile31(resolve39(worktreePath, "package-lock.json")).catch(() => void 0);
+  const lockfile = await readFile32(resolve40(worktreePath, "package-lock.json")).catch(() => void 0);
   if (!lockfile)
     return { failure: "no-lockfile" };
   const packages = parseLockfilePackages(lockfile);
@@ -45055,11 +45292,11 @@ async function seedWarmNodeModules(input) {
     return { reason: plan.failure, ...plan.detail ? { detail: plan.detail } : {} };
   }
   for (const tree of plan.trees) {
-    if (await pathExists(resolve39(input.worktreePath, tree))) {
+    if (await pathExists(resolve40(input.worktreePath, tree))) {
       return { reason: "present", key: plan.key };
     }
   }
-  const entry = resolve39(input.storeRoot, plan.key);
+  const entry = resolve40(input.storeRoot, plan.key);
   if (!await isDirectory(entry))
     return { reason: "cold", key: plan.key };
   const [storeDevice, checkoutDevice] = await Promise.all([
@@ -45069,19 +45306,19 @@ async function seedWarmNodeModules(input) {
   if (storeDevice === void 0 || storeDevice !== checkoutDevice) {
     return { reason: "cross-device", key: plan.key };
   }
-  const staging = resolve39(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID14()}`);
+  const staging = resolve40(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID14()}`);
   const placed = [];
   const now2 = (input.now ?? Date.now)();
   try {
     await sweepStaleStaging(input.storeRoot, now2);
     await utimes(entry, now2 / 1e3, now2 / 1e3).catch(() => void 0);
     for (const tree of plan.trees) {
-      await cloneTree(resolve39(entry, tree), resolve39(staging, tree), seedFile);
+      await cloneTree(resolve40(entry, tree), resolve40(staging, tree), seedFile);
     }
     for (const tree of plan.trees) {
-      const target = resolve39(input.worktreePath, tree);
+      const target = resolve40(input.worktreePath, tree);
       await mkdir26(dirname25(target), { recursive: true });
-      await rename11(resolve39(staging, tree), target);
+      await rename11(resolve40(staging, tree), target);
       placed.push(target);
     }
     return { reason: "seeded", key: plan.key };
@@ -45099,11 +45336,11 @@ async function harvestWarmNodeModules(input) {
   if (isPlanRefusal(plan)) {
     return { reason: plan.failure, ...plan.detail ? { detail: plan.detail } : {} };
   }
-  const entry = resolve39(input.storeRoot, plan.key);
+  const entry = resolve40(input.storeRoot, plan.key);
   if (await pathExists(entry))
     return { reason: "already-warm", key: plan.key };
   for (const tree of plan.trees) {
-    if (!await isDirectory(resolve39(input.worktreePath, tree))) {
+    if (!await isDirectory(resolve40(input.worktreePath, tree))) {
       return { reason: "no-node-modules", key: plan.key, detail: tree };
     }
   }
@@ -45115,12 +45352,12 @@ async function harvestWarmNodeModules(input) {
       detail: `${missing.length} absent, e.g. ${missing.slice(0, 3).join(", ")}`
     };
   }
-  const staging = resolve39(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID14()}`);
+  const staging = resolve40(input.storeRoot, `${STAGING_PREFIX}${process.pid}.${randomUUID14()}`);
   try {
     await mkdir26(input.storeRoot, { recursive: true, mode: 493 });
     await sweepStaleStaging(input.storeRoot, (input.now ?? Date.now)());
     for (const tree of plan.trees) {
-      await cloneTree(resolve39(input.worktreePath, tree), resolve39(staging, tree), harvestFile);
+      await cloneTree(resolve40(input.worktreePath, tree), resolve40(staging, tree), harvestFile);
     }
     await input.onCopied?.();
     if (!await stagedTreeIsPublishable(input.worktreePath, staging, plan.key)) {
@@ -45143,16 +45380,16 @@ async function stagedTreeIsPublishable(worktreePath, staging, key) {
     return false;
   const hidden = join19("node_modules", ".package-lock.json");
   const [copied, current] = await Promise.all([
-    readFile31(resolve39(staging, hidden)).catch(() => void 0),
-    readFile31(resolve39(worktreePath, hidden)).catch(() => void 0)
+    readFile32(resolve40(staging, hidden)).catch(() => void 0),
+    readFile32(resolve40(worktreePath, hidden)).catch(() => void 0)
   ]);
   if (!copied || !current || !copied.equals(current))
     return false;
   return (await missingInstalledPackages(worktreePath, staging)).length === 0;
 }
 async function missingInstalledPackages(worktreePath, treeRoot = worktreePath) {
-  const wanted = parseLockfilePackages(await readFile31(resolve39(worktreePath, "package-lock.json")).catch(() => void 0));
-  const installed = parseLockfilePackages(await readFile31(resolve39(treeRoot, "node_modules", ".package-lock.json")).catch(() => void 0));
+  const wanted = parseLockfilePackages(await readFile32(resolve40(worktreePath, "package-lock.json")).catch(() => void 0));
+  const installed = parseLockfilePackages(await readFile32(resolve40(treeRoot, "node_modules", ".package-lock.json")).catch(() => void 0));
   if (!wanted)
     return ["package-lock.json is unreadable"];
   if (!installed)
@@ -45172,7 +45409,7 @@ async function missingInstalledPackages(worktreePath, treeRoot = worktreePath) {
       required.push(path);
   }
   await mapWithLimit(required, INTEGRITY_READ_CONCURRENCY, async (path) => {
-    if (!(path in installed) || !await isInstalledPackage(resolve39(treeRoot, path))) {
+    if (!(path in installed) || !await isInstalledPackage(resolve40(treeRoot, path))) {
       missing.push(path);
     }
   });
@@ -45212,7 +45449,7 @@ function isContainedTreePath(value) {
 }
 async function cloneTree(source, target, file, topLevel = true) {
   await mkdir26(target, { recursive: true, mode: 493 });
-  for (const entry of await readdir11(source, { withFileTypes: true })) {
+  for (const entry of await readdir12(source, { withFileTypes: true })) {
     const from = join19(source, entry.name);
     const to = join19(target, entry.name);
     if (entry.isSymbolicLink()) {
@@ -45241,10 +45478,10 @@ var seedFile = async (source, target, topLevel) => {
   await chmod10(target, 420);
 };
 async function pruneWarmStore(storeRoot, keep) {
-  const names = (await readdir11(storeRoot).catch(() => [])).filter((name) => !name.startsWith(STAGING_PREFIX));
+  const names = (await readdir12(storeRoot).catch(() => [])).filter((name) => !name.startsWith(STAGING_PREFIX));
   const entries = [];
   for (const name of names) {
-    const info = await lstat7(join19(storeRoot, name)).catch(() => void 0);
+    const info = await lstat8(join19(storeRoot, name)).catch(() => void 0);
     if (info?.isDirectory())
       entries.push({ name, usedAt: info.mtimeMs });
   }
@@ -45255,19 +45492,19 @@ async function pruneWarmStore(storeRoot, keep) {
   return dropped.map((entry) => entry.name);
 }
 async function sweepStaleStaging(storeRoot, now2) {
-  const entries = await readdir11(storeRoot).catch(() => []);
+  const entries = await readdir12(storeRoot).catch(() => []);
   for (const name of entries) {
     if (!name.startsWith(STAGING_PREFIX))
       continue;
     const path = join19(storeRoot, name);
-    const info = await lstat7(path).catch(() => void 0);
+    const info = await lstat8(path).catch(() => void 0);
     if (!info || now2 - info.mtimeMs < STAGING_SWEEP_MS)
       continue;
     await rm18(path, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function pathExists(path) {
-  return lstat7(path).then(() => true, () => false);
+  return lstat8(path).then(() => true, () => false);
 }
 async function deviceOf(path) {
   return stat11(path).then((info) => info.dev, () => void 0);
@@ -45830,7 +46067,7 @@ var MonolithCornerTurnLoop = class {
       this.options.api.execute("getCornerRestoreState", { cornerId: this.options.cornerId })
     ]);
     const { hostRoutes: grantedHostRoutes, devices: grantedDevices, isolatedCategories } = grants;
-    const privateAssetRoot = resolve40(runtimeDirectory(this.options.runtime.supervisorRoot, this.options.runtime.agent.publicKey), "private-assets");
+    const privateAssetRoot = resolve41(runtimeDirectory(this.options.runtime.supervisorRoot, this.options.runtime.agent.publicKey), "private-assets");
     const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const opener = this.options.openedBy ? roster.members.find((member) => member.identityId === this.options.openedBy) : void 0;
     const reviewer = Boolean(this.options.repository) && configuration.isReviewer === true;
@@ -45954,12 +46191,12 @@ var MonolithCornerTurnLoop = class {
       await prepareCodexCacheTargets(homeOverlay.CODEX_HOME);
     if (assets && homeOverlay.HOME)
       await preparePackageCacheTargets(homeOverlay.HOME);
-    const cargoTargetDir = resolve40(this.options.worktreePath, ".beeline-cargo-target");
+    const cargoTargetDir = resolve41(this.options.worktreePath, ".beeline-cargo-target");
     const npmCacheDir = cacheEnv.npm_config_cache ?? sharedNpmCacheDir(this.options.runtime.supervisorRoot);
     const pnpmStoreDir = cacheEnv.PNPM_CONFIG_STORE_DIR ?? sharedPnpmStoreDir(this.options.runtime.supervisorRoot);
     const turboCacheDir = cacheEnv.TURBO_CACHE_DIR ?? sharedTurboCacheDir(this.options.runtime.supervisorRoot);
-    const modelCacheDir = cacheEnv.HF_HUB_CACHE ?? resolve40(this.options.runtime.supervisorRoot, "beeline", "model-cache");
-    const hfHomeDir = assets && this.options.config.agentHomeRoot ? resolve40(this.options.config.agentHomeRoot, "cache/huggingface-private") : modelCacheDir;
+    const modelCacheDir = cacheEnv.HF_HUB_CACHE ?? resolve41(this.options.runtime.supervisorRoot, "beeline", "model-cache");
+    const hfHomeDir = assets && this.options.config.agentHomeRoot ? resolve41(this.options.config.agentHomeRoot, "cache/huggingface-private") : modelCacheDir;
     await Promise.all([npmCacheDir, pnpmStoreDir, cargoTargetDir, turboCacheDir, modelCacheDir].map((path) => mkdir27(path, { recursive: true, mode: 448 })));
     const agentEnv = {
       ...this.options.config.agentEnv,
@@ -45971,7 +46208,7 @@ var MonolithCornerTurnLoop = class {
       ...cacheEnv,
       ...androidAssets && this.options.config.agentHomeRoot ? {
         ANDROID_AVD_HOME: androidAssets.avdBase,
-        ANDROID_EMULATOR_HOME: resolve40(this.options.config.agentHomeRoot, "android-emulator")
+        ANDROID_EMULATOR_HOME: resolve41(this.options.config.agentHomeRoot, "android-emulator")
       } : {},
       npm_config_cache: npmCacheDir,
       // pnpm reads its settings from PNPM_CONFIG_* environment variables and
@@ -45982,14 +46219,14 @@ var MonolithCornerTurnLoop = class {
       HF_HOME: hfHomeDir,
       HUGGINGFACE_HUB_CACHE: assets || isolatedCategories.includes("package-cache") ? modelCacheDir : join20(modelCacheDir, "hub"),
       ...assets && androidAssets && this.options.config.agentHomeRoot ? {
-        BEELINE_ANDROID_LEASE_ROOT: resolve40(assets.cache, "android-leases"),
-        BEELINE_ANDROID_INSTANCE_ROOT: resolve40(this.options.config.agentHomeRoot, "android-instances"),
+        BEELINE_ANDROID_LEASE_ROOT: resolve41(assets.cache, "android-leases"),
+        BEELINE_ANDROID_INSTANCE_ROOT: resolve41(this.options.config.agentHomeRoot, "android-instances"),
         BEELINE_ANDROID_BASE_AVD_HOME: androidAssets.avdBase,
-        BEELINE_ANDROID_EMULATOR_BINARY: resolve40(homeOverlay.ANDROID_HOME, "emulator/emulator")
+        BEELINE_ANDROID_EMULATOR_BINARY: resolve41(homeOverlay.ANDROID_HOME, "emulator/emulator")
       } : {}
     };
     if (toolchain && assets) {
-      agentEnv.PATH = `${resolve40(toolchain.binDir, "../../bin")}:${toolchain.binDir}:${agentEnv.PATH ?? ""}`;
+      agentEnv.PATH = `${resolve41(toolchain.binDir, "../../bin")}:${toolchain.binDir}:${agentEnv.PATH ?? ""}`;
       if (this.options.config.agentKind === "pi")
         agentEnv.PI_ACP_PI_COMMAND = toolchain.cliCommand;
     }
@@ -46253,7 +46490,7 @@ var MonolithCornerTurnLoop = class {
           briefRevision: restore.brief?.revision
         }),
         ...this.options.config.agentHomeRoot && this.options.config.agentKind && !AGENT_SKILL_DIRS.includes(this.options.config.agentKind) ? [
-          `This harness has no verified native skill discovery. Read the release-managed review procedure at ${resolve40(this.options.config.agentHomeRoot, "codex", "skills", "beeline-review", "SKILL.md")} before the verdict.`
+          `This harness has no verified native skill discovery. Read the release-managed review procedure at ${resolve41(this.options.config.agentHomeRoot, "codex", "skills", "beeline-review", "SKILL.md")} before the verdict.`
         ] : []
       ].join("\n");
     } catch {
@@ -46371,8 +46608,8 @@ var MonolithCornerTurnLoop = class {
         let timer;
         const stats = statsPromise && remaining > 0 ? await Promise.race([
           statsPromise,
-          new Promise((resolve52) => {
-            timer = setTimeout(() => resolve52(void 0), remaining);
+          new Promise((resolve53) => {
+            timer = setTimeout(() => resolve53(void 0), remaining);
           })
         ]).finally(() => {
           if (timer)
@@ -46437,7 +46674,7 @@ var MonolithCornerTurnLoop = class {
             const briefDelivered = this.attachmentDir && briefAttachments.length ? await deliverAttachments(briefAttachments, join20(this.attachmentDir, requestId.replace(/[^\w-]/g, "_"), "brief", String(assignedBrief.revision)), this.options.fetchImpl) : [];
             briefFileLines = await Promise.all((assignedBrief?.attachments ?? []).map(async (file, index) => {
               const entry = briefDelivered.find((item) => item.attachment === briefAttachments[index]);
-              const verified = entry?.path && createHash16("sha256").update(await readFile32(entry.path)).digest("hex") === file.sha256;
+              const verified = entry?.path && createHash16("sha256").update(await readFile33(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"}`;
             }));
             missingRequiredBriefFile = (assignedBrief?.attachments ?? []).some((file, index) => file.required && briefFileLines[index]?.includes("UNAVAILABLE OR CONTENT MISMATCH"));
@@ -46875,13 +47112,13 @@ ${continuation}` : assembled;
     if (this.harvest || !this.options.repository || this.options.config.agentSharedAssetRoot)
       return;
     const { cornerId, worktreePath, runtime } = this.options;
-    const mobilePath = resolve40(worktreePath, "apps/mobile");
+    const mobilePath = resolve41(worktreePath, "apps/mobile");
     const jobs = [
       harvestWarmNodeModules({
         worktreePath,
         storeRoot: warmNodeModulesStoreDir(runtime.supervisorRoot)
       }),
-      ...existsSync9(resolve40(mobilePath, "package-lock.json")) ? [
+      ...existsSync9(resolve41(mobilePath, "package-lock.json")) ? [
         harvestWarmNodeModules({
           worktreePath: mobilePath,
           storeRoot: mobileNodeModulesStoreDir(runtime.supervisorRoot)
@@ -46929,7 +47166,7 @@ ${continuation}` : assembled;
         const delay = outage ? Math.min(2e3 * 2 ** attempt, 3e4) : 250 * (attempt + 1);
         if ((outage ? Date.now() + delay > outageDeadline : attempt === 2) || this.forcedStop || this.currentTurn && this.stoppedTurns.has(this.currentTurn.requestId))
           throw error;
-        await new Promise((resolve52) => setTimeout(resolve52, delay));
+        await new Promise((resolve53) => setTimeout(resolve53, delay));
       }
     }
     if (!token)
@@ -47029,8 +47266,8 @@ ${continuation}` : assembled;
 
 // apps/body/dist/corner-disk-recovery.js
 import { execFile as execFile18 } from "node:child_process";
-import { lstat as lstat8, readdir as readdir12, realpath as realpath3, rm as rm19 } from "node:fs/promises";
-import { basename as basename10, dirname as dirname27, join as join21, relative as relative3, resolve as resolve41, sep as sep3 } from "node:path";
+import { lstat as lstat9, readdir as readdir13, realpath as realpath3, rm as rm19 } from "node:fs/promises";
+import { basename as basename10, dirname as dirname27, join as join21, relative as relative3, resolve as resolve42, sep as sep3 } from "node:path";
 import { promisify as promisify12 } from "node:util";
 var execFileAsync12 = promisify12(execFile18);
 var GENERATED_DIRS = /* @__PURE__ */ new Set([
@@ -47045,11 +47282,11 @@ var GENERATED_DIRS = /* @__PURE__ */ new Set([
 var MAX_DIRECTORY_DEPTH = 4;
 var MAX_VISITED_DIRECTORIES = 5e3;
 function cornerRecoveryPointerPath(worktree) {
-  const checkout = resolve41(worktree.path);
+  const checkout = resolve42(worktree.path);
   if (basename10(checkout) !== worktree.cornerId || basename10(dirname27(checkout)) !== "corners" || basename10(dirname27(dirname27(checkout))) !== "beeline" || !/^[a-zA-Z0-9-]{1,80}$/.test(worktree.cornerId)) {
     throw new Error("refusing recovery pointer outside a Beeline corner checkout");
   }
-  return resolve41(dirname27(dirname27(checkout)), "recovery", "corners", `${worktree.cornerId}.json`);
+  return resolve42(dirname27(dirname27(checkout)), "recovery", "corners", `${worktree.cornerId}.json`);
 }
 async function git(checkout, args) {
   const result = await execFileAsync12("git", ["-C", checkout, ...args], {
@@ -47067,9 +47304,9 @@ async function ignoredAndUntracked(checkout, path) {
   return !(await git(checkout, ["ls-files", "--", rel])).trim();
 }
 async function preserveUnpublishedCornerWorktree(worktree, reason) {
-  const checkout = resolve41(worktree.path);
+  const checkout = resolve42(worktree.path);
   const pointer = cornerRecoveryPointerPath(worktree);
-  const info = await lstat8(checkout);
+  const info = await lstat9(checkout);
   if (!info.isDirectory() || await realpath3(checkout) !== checkout) {
     throw new Error("refusing to prune a non-canonical corner checkout");
   }
@@ -47093,7 +47330,7 @@ async function preserveUnpublishedCornerWorktree(worktree, reason) {
       break;
     if (current.depth >= MAX_DIRECTORY_DEPTH)
       continue;
-    for (const entry of await readdir12(current.path, { withFileTypes: true })) {
+    for (const entry of await readdir13(current.path, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name === ".git")
         continue;
       const path = join21(current.path, entry.name);
@@ -47629,7 +47866,7 @@ function cornerStartConfigKey(repository, objective) {
 function cornerRepositoryCacheDir(supervisorRoot2, remote) {
   const normalizedRemote = roomCheckoutRemote(remote);
   const repositoryHash = createHash17("sha256").update(normalizedRemote).digest("hex").slice(0, 24);
-  return resolve42(supervisorRoot2, "beeline", "repositories", `${repositoryHash}.git`);
+  return resolve43(supervisorRoot2, "beeline", "repositories", `${repositoryHash}.git`);
 }
 function isStandingCornerStartFault(error) {
   const text2 = error instanceof Error ? error.message : String(error);
@@ -47638,11 +47875,11 @@ function isStandingCornerStartFault(error) {
 async function materializeCornerWorktree(input) {
   const remote = roomCheckoutRemote(input.remote);
   const gitCommonDir = cornerRepositoryCacheDir(input.supervisorRoot, remote);
-  const path = resolve42(input.supervisorRoot, "beeline", "corners", input.cornerId);
+  const path = resolve43(input.supervisorRoot, "beeline", "corners", input.cornerId);
   await mkdir28(dirname28(gitCommonDir), { recursive: true, mode: 448 });
   await mkdir28(dirname28(path), { recursive: true, mode: 448 });
   const authEnv = githubGitEnv(input.token);
-  if (!existsSync10(resolve42(gitCommonDir, "HEAD"))) {
+  if (!existsSync10(resolve43(gitCommonDir, "HEAD"))) {
     await execFileAsync13("git", ["clone", "--bare", remote, gitCommonDir], {
       env: authEnv,
       maxBuffer: 4 * 1024 * 1024
@@ -47665,7 +47902,7 @@ async function materializeCornerWorktree(input) {
       return false;
     throw error;
   });
-  if (!existsSync10(resolve42(path, ".git"))) {
+  if (!existsSync10(resolve43(path, ".git"))) {
     await rm20(path, { recursive: true, force: true });
     await execFileAsync13("git", [
       `--git-dir=${gitCommonDir}`,
@@ -47683,8 +47920,8 @@ async function materializeCornerWorktree(input) {
     if (seed.reason !== "no-lockfile") {
       console.log(`[thin-core] corner ${input.cornerId} warm node_modules: ${seed.reason}${seed.detail ? ` (${seed.detail})` : ""}`);
     }
-    const mobilePath = resolve42(path, "apps/mobile");
-    if (existsSync10(resolve42(mobilePath, "package-lock.json"))) {
+    const mobilePath = resolve43(path, "apps/mobile");
+    if (existsSync10(resolve43(mobilePath, "package-lock.json"))) {
       const mobileSeed = input.workspaceId ? { reason: "no-lockfile" } : await seedWarmNodeModules({
         worktreePath: mobilePath,
         storeRoot: mobileNodeModulesStoreDir(input.supervisorRoot)
@@ -47742,9 +47979,9 @@ async function mapWithConcurrency(values, limit, visit) {
   }));
 }
 async function discoverCornerWorktree(supervisorRoot2, cornerId) {
-  const cornersRoot = resolve42(supervisorRoot2, "beeline", "corners");
-  const path = resolve42(cornersRoot, cornerId);
-  if (dirname28(path) !== cornersRoot || !existsSync10(resolve42(path, ".git")))
+  const cornersRoot = resolve43(supervisorRoot2, "beeline", "corners");
+  const path = resolve43(cornersRoot, cornerId);
+  if (dirname28(path) !== cornersRoot || !existsSync10(resolve43(path, ".git")))
     return void 0;
   const [canonicalRoot, canonicalPath] = await Promise.all([
     realpath4(cornersRoot),
@@ -47756,8 +47993,8 @@ async function discoverCornerWorktree(supervisorRoot2, cornerId) {
   const common = await execFileAsync13("git", ["-C", path, "rev-parse", "--git-common-dir"]).catch(() => void 0);
   if (!common)
     return void 0;
-  const gitCommonDir = resolve42(path, common.stdout.trim());
-  const repositoriesRoot = resolve42(supervisorRoot2, "beeline", "repositories");
+  const gitCommonDir = resolve43(path, common.stdout.trim());
+  const repositoriesRoot = resolve43(supervisorRoot2, "beeline", "repositories");
   const commonRelative = relative4(repositoriesRoot, gitCommonDir);
   if (!commonRelative || commonRelative === ".." || commonRelative.startsWith(`..${sep4}`) || commonRelative.startsWith(sep4)) {
     throw new Error(`refusing corner ${cornerId} with git directory outside repository cache`);
@@ -47765,8 +48002,8 @@ async function discoverCornerWorktree(supervisorRoot2, cornerId) {
   return { path, gitCommonDir };
 }
 async function localCornerWorktreeIds(supervisorRoot2) {
-  const root = resolve42(supervisorRoot2, "beeline", "corners");
-  const entries = await readdir13(root, { withFileTypes: true }).catch((error) => {
+  const root = resolve43(supervisorRoot2, "beeline", "corners");
+  const entries = await readdir14(root, { withFileTypes: true }).catch((error) => {
     if (error.code === "ENOENT")
       return [];
     throw error;
@@ -47871,14 +48108,14 @@ async function originContains(gitCommonDir, head) {
 }
 var execFileAsync13 = promisify13(execFile19);
 async function removeCornerScratchWorkspace(input) {
-  const expected = resolve42(input.roomRoot, "scratch");
-  if (resolve42(input.scratchPath) !== expected) {
+  const expected = resolve43(input.roomRoot, "scratch");
+  if (resolve43(input.scratchPath) !== expected) {
     throw new Error(`refusing to remove scratch outside corner ${input.cornerId}`);
   }
-  for (const entry of await readdir13(expected, { withFileTypes: true }).catch(() => [])) {
+  for (const entry of await readdir14(expected, { withFileTypes: true }).catch(() => [])) {
     if (entry.name === "agent-home" || entry.name === "agent-private")
       continue;
-    await rm20(resolve42(expected, entry.name), { recursive: true, force: true });
+    await rm20(resolve43(expected, entry.name), { recursive: true, force: true });
   }
 }
 var RoomRuntimeCoordinator = class {
@@ -47897,8 +48134,8 @@ var RoomRuntimeCoordinator = class {
   localWorktreeIds;
   /** Event-driven cleanup retries stay scoped to the failed local corner. */
   archiveCleanupFaults = /* @__PURE__ */ new Map();
-  /** A refused local checkout is kept until a later Room listing proves membership again. */
-  archiveCleanupAccessDenied = /* @__PURE__ */ new Set();
+  /** A non-retryable refusal parks this local checkout for the rest of this core's lifetime. */
+  archiveCleanupRefused = /* @__PURE__ */ new Set();
   /**
    * A corner whose branch cleanup found commits no origin ref contains. That
    * is never transient - nothing pushes them later - so retrying it every
@@ -48354,13 +48591,13 @@ var RoomRuntimeCoordinator = class {
     return this.runtime.rooms.find((room) => room.channelId === roomId);
   }
   roomRoot(roomId) {
-    return this.roomRecord(roomId)?.root ?? resolve42(dirname28(this.configPath), "rooms", roomId);
+    return this.roomRecord(roomId)?.root ?? resolve43(dirname28(this.configPath), "rooms", roomId);
   }
   roomAgentHomeRoot(workspaceRoot, required = false) {
     const flag = process.env.BUZZY_BODY_ROOM_HOME;
     if (!required && flag === "0")
       return void 0;
-    const home = resolve42(workspaceRoot, "agent-home");
+    const home = resolve43(workspaceRoot, "agent-home");
     if (!required && flag !== "1" && !existsSync10(home) && existsSync10(workspaceRoot))
       return void 0;
     try {
@@ -48377,8 +48614,8 @@ var RoomRuntimeCoordinator = class {
       ...this.baseConfig,
       workspaceRoot,
       ...process.env.BEELINE_SHARED_ASSETS_ENABLED === "0" ? { agentSharedAssetRoot: void 0 } : { agentSharedAssetRoot: workspaceAssetRoot(this.runtime.supervisorRoot, this.runtime.communityId) },
-      agentPrivateRoot: resolve42(workspaceRoot, "agent-private"),
-      agentMemoryRoot: resolve42(dirname28(this.configPath), "memory"),
+      agentPrivateRoot: resolve43(workspaceRoot, "agent-private"),
+      agentMemoryRoot: resolve43(dirname28(this.configPath), "memory"),
       openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname28(this.configPath)),
       turnTraceDir: turnTraceDirectory(dirname28(this.configPath)),
       ...agentHomeRoot ? { agentHomeRoot } : {}
@@ -48461,11 +48698,11 @@ var RoomRuntimeCoordinator = class {
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
     const checkoutId = createHash17("sha256").update(`${roomId}\0${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
-    const path = resolve42(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
+    const path = resolve43(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
     await mkdir28(dirname28(path), { recursive: true, mode: 448 });
     const token = remote.startsWith("https://github.com/") ? await this.parentRepositoryToken(roomId) : void 0;
     const env = token ? githubGitEnv(token.token) : process.env;
-    if (!existsSync10(resolve42(path, ".git"))) {
+    if (!existsSync10(resolve43(path, ".git"))) {
       await execFileAsync13("git", ["clone", "--no-checkout", remote, path], {
         env,
         maxBuffer: 4 * 1024 * 1024
@@ -48552,10 +48789,10 @@ var RoomRuntimeCoordinator = class {
         featureBranch,
         token: granted.token
       }) : void 0;
-      const workspacePath = worktree?.path ?? resolve42(this.roomRoot(corner.cornerId), "scratch");
+      const workspacePath = worktree?.path ?? resolve43(this.roomRoot(corner.cornerId), "scratch");
       if (!worktree)
         await mkdir28(workspacePath, { recursive: true, mode: 448 });
-      await writePrivateFileAtomically(resolve42(this.roomRoot(corner.cornerId), ".beeline-corner.json"), `${JSON.stringify({ cornerId: corner.cornerId, parentRoomId: corner.parentRoomId })}
+      await writePrivateFileAtomically(resolve43(this.roomRoot(corner.cornerId), ".beeline-corner.json"), `${JSON.stringify({ cornerId: corner.cornerId, parentRoomId: corner.parentRoomId })}
 `);
       if (worktree && shouldPostInitialCornerWorkingState(restore)) {
         await this.options.daemonApi.execute("postCornerRemoteState", {
@@ -48880,7 +49117,7 @@ var RoomRuntimeCoordinator = class {
         this.archiveCleanupAbandoned.delete(cornerId);
         continue;
       }
-      if (this.archiveCleanupAbandoned.has(cornerId))
+      if (this.archiveCleanupAbandoned.has(cornerId) || this.archiveCleanupRefused.has(cornerId))
         continue;
       if (!this.archiveCleanupDue(cornerId))
         continue;
@@ -48898,7 +49135,10 @@ var RoomRuntimeCoordinator = class {
           console.error(`[thin-core] corner ${cornerId} branch cleanup abandoned; unpublished work kept:`, error);
           continue;
         }
-        this.deferArchiveCleanup(cornerId);
+        if (error instanceof DaemonApiError && error.status >= 400 && error.status < 500 && !error.retryable)
+          this.archiveCleanupRefused.add(cornerId);
+        else
+          this.deferArchiveCleanup(cornerId);
         console.error(`[thin-core] corner ${cornerId} branch cleanup retry failed:`, error);
       }
     }
@@ -48917,9 +49157,8 @@ var RoomRuntimeCoordinator = class {
         continue;
       if (this.archiveCleanupAbandoned.has(cornerId))
         continue;
-      if (this.archiveCleanupAccessDenied.has(cornerId) && !corners.has(cornerId))
+      if (this.archiveCleanupRefused.has(cornerId))
         continue;
-      this.archiveCleanupAccessDenied.delete(cornerId);
       let corner = corners.get(cornerId);
       let discovered;
       let candidate;
@@ -48948,7 +49187,7 @@ var RoomRuntimeCoordinator = class {
           throw new Error(`archived corner ${corner.cornerId} has no authoritative repository`);
         }
         const expectedCommonDir = cornerRepositoryCacheDir(this.runtime.supervisorRoot, repository.remote);
-        if (resolve42(discovered.gitCommonDir) !== expectedCommonDir) {
+        if (resolve43(discovered.gitCommonDir) !== expectedCommonDir) {
           throw new Error(`archived corner ${corner.cornerId} repository cache does not match`);
         }
         if (!restore.featureBranch) {
@@ -48975,8 +49214,8 @@ var RoomRuntimeCoordinator = class {
           }
           continue;
         }
-        if (error instanceof DaemonApiError && error.status === 403)
-          this.archiveCleanupAccessDenied.add(cornerId);
+        if (error instanceof DaemonApiError && error.status >= 400 && error.status < 500 && !error.retryable)
+          this.archiveCleanupRefused.add(cornerId);
         else
           this.deferArchiveCleanup(cornerId);
         console.error(`[thin-core] archived corner ${cornerId} cleanup deferred:`, error);
@@ -49036,10 +49275,10 @@ var RoomRuntimeCoordinator = class {
   async cleanupArchivedCornerLocalState(cornerId, knownArchive) {
     if (this.running.has(cornerId) || this.startingCorners.has(cornerId))
       return false;
-    const root = resolve42(dirname28(this.configPath), "rooms", cornerId);
+    const root = resolve43(dirname28(this.configPath), "rooms", cornerId);
     if (this.roomRoot(cornerId) !== root || !/^[a-zA-Z0-9-]{1,80}$/.test(cornerId))
       return false;
-    const info = await lstat9(root).catch(() => void 0);
+    const info = await lstat10(root).catch(() => void 0);
     if (!info?.isDirectory() || await realpath4(root) !== root)
       return false;
     let archived = knownArchive?.has(cornerId) ?? false;
@@ -49057,9 +49296,9 @@ var RoomRuntimeCoordinator = class {
     await removeCornerScratchWorkspace({
       cornerId,
       roomRoot: root,
-      scratchPath: resolve42(root, "scratch")
+      scratchPath: resolve43(root, "scratch")
     });
-    await rm20(resolve42(root, ".beeline-corner.json"), { force: true });
+    await rm20(resolve43(root, ".beeline-corner.json"), { force: true });
     return true;
   }
   /** Recover chat-only scratch and per-member homes after missed close events
@@ -49067,18 +49306,18 @@ var RoomRuntimeCoordinator = class {
    * checkout has already gone; a scratch directory identifies legacy chat
    * corners. Active scratch gets a 14-day file TTL, never a wholesale reap. */
   async sweepCornerLocalState(archived, desired) {
-    const root = resolve42(dirname28(this.configPath), "rooms");
+    const root = resolve43(dirname28(this.configPath), "rooms");
     const due = this.now() - this.lastCornerScratchSweepAt >= 6 * 60 * 6e4;
     if (due)
       this.lastCornerScratchSweepAt = this.now();
-    for (const entry of await readdir13(root, { withFileTypes: true }).catch(() => [])) {
+    for (const entry of await readdir14(root, { withFileTypes: true }).catch(() => [])) {
       if (!entry.isDirectory() || !/^[a-zA-Z0-9-]{1,80}$/.test(entry.name))
         continue;
-      const roomRoot = resolve42(root, entry.name);
-      const scratch = resolve42(roomRoot, "scratch");
-      const marker = resolve42(roomRoot, ".beeline-corner.json");
-      const hasScratch = (await lstat9(scratch).catch(() => void 0))?.isDirectory() ?? false;
-      const hasMarker = (await lstat9(marker).catch(() => void 0))?.isFile() ?? false;
+      const roomRoot = resolve43(root, entry.name);
+      const scratch = resolve43(roomRoot, "scratch");
+      const marker = resolve43(roomRoot, ".beeline-corner.json");
+      const hasScratch = (await lstat10(scratch).catch(() => void 0))?.isDirectory() ?? false;
+      const hasMarker = (await lstat10(marker).catch(() => void 0))?.isFile() ?? false;
       if (!hasScratch && !hasMarker)
         continue;
       if (desired.has(entry.name)) {
@@ -49249,6 +49488,7 @@ var ThinDaemonCore = class {
   pendingDiscovery = false;
   discoveryWaiter;
   discoveryStatus = "starting";
+  progressWaiters = /* @__PURE__ */ new Set();
   constructor(runtime, configPath, baseConfig, options) {
     if (!runtime.transport)
       throw new Error("thin daemon requires monolith transport");
@@ -49259,7 +49499,7 @@ var ThinDaemonCore = class {
     });
   }
   async waitForDiscovery(signal) {
-    if (this.pendingDiscovery || signal?.aborted)
+    if (this.pendingDiscovery || this.progressWaiters.size || signal?.aborted)
       return;
     await new Promise((resolveWait) => {
       const done = () => {
@@ -49269,10 +49509,17 @@ var ThinDaemonCore = class {
       };
       this.discoveryWaiter = done;
       signal?.addEventListener("abort", done, { once: true });
-      if (this.pendingDiscovery)
+      if (this.pendingDiscovery || this.progressWaiters.size)
         done();
     });
   }
+  /** The existing machine watchdog tick wakes this loop without discovering Rooms. */
+  requestWorkLoopProgress() {
+    return new Promise((resolveProgress) => {
+      this.progressWaiters.add(resolveProgress);
+      this.discoveryWaiter?.();
+    });
+  }
   activeRoomIds() {
     return this.roomRuntime.activeRoomIds();
   }
@@ -49336,19 +49583,25 @@ var ThinDaemonCore = class {
         await opts.onEstablished?.();
       const supervisor2 = this.roomRuntime.supervisor;
       let failures = 0;
+      let discover = true;
       while (!opts.signal?.aborted) {
-        this.pendingDiscovery = false;
+        const acknowledge = [...this.progressWaiters];
+        const shouldDiscover = discover || this.pendingDiscovery;
+        if (shouldDiscover)
+          this.pendingDiscovery = false;
         const wakesBefore = supervisor2.wakes;
         try {
-          const membership = await this.roomRuntime.reconcile();
-          if (membership === "not-member")
-            return "agent-removed";
-          this.discoveryStatus = membership === "unknown" ? "monolith membership degraded" : "";
-          failures = 0;
+          if (shouldDiscover) {
+            const membership = await this.roomRuntime.reconcile();
+            if (membership === "not-member")
+              return "agent-removed";
+            this.discoveryStatus = membership === "unknown" ? "monolith membership degraded" : "";
+            failures = 0;
+          }
         } catch (error) {
           if (isAgentRemovedError(error))
             return "agent-removed";
-          failures += 1;
+          failures = error instanceof DaemonApiError && !error.retryable ? supervisor2.retries + 1 : failures + 1;
           console.error(failures > supervisor2.retries ? "[thin-core] discovery failed; waiting for the next live open or discovery wake:" : `[thin-core] discovery failed; retry ${failures} of ${supervisor2.retries}:`, error);
           this.discoveryStatus = `monolith discovery degraded: ${error instanceof Error ? error.message : String(error)}`;
           this.roomRuntime.suspectLink(error);
@@ -49356,16 +49609,24 @@ var ThinDaemonCore = class {
         if (opts.signal?.aborted)
           break;
         await opts.onProgress?.(this.healthStatus());
-        if (failures > 0) {
+        for (const done of acknowledge) {
+          this.progressWaiters.delete(done);
+          done();
+        }
+        if (failures > 0 && failures <= supervisor2.retries) {
           await supervisor2.retryDelay(failures, opts.signal, wakesBefore);
-          if (failures > supervisor2.retries)
-            failures = 0;
-        } else if (!this.pendingDiscovery) {
+          discover = true;
+        } else {
+          failures = 0;
           await this.waitForDiscovery(opts.signal);
+          discover = this.pendingDiscovery;
         }
       }
       return "aborted";
     } finally {
+      for (const done of this.progressWaiters)
+        done();
+      this.progressWaiters.clear();
       opts.signal?.removeEventListener("abort", stop);
       await this.roomRuntime.shutdown();
     }
@@ -49374,10 +49635,10 @@ var ThinDaemonCore = class {
 
 // apps/body/dist/force-update-journal.js
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { resolve as resolve43 } from "node:path";
+import { resolve as resolve44 } from "node:path";
 var NAME = "force-update-interruptions.json";
 function pathFor(runtimeDir) {
-  return resolve43(runtimeDir, NAME);
+  return resolve44(runtimeDir, NAME);
 }
 function read(runtimeDir) {
   try {
@@ -49455,17 +49716,17 @@ function staleGeneration(error) {
 init_launchd();
 init_systemd();
 import { mkdir as mkdir29, rename as rename12 } from "node:fs/promises";
-import { dirname as dirname29, resolve as resolve44 } from "node:path";
+import { dirname as dirname29, resolve as resolve45 } from "node:path";
 async function retireRemovedAgent(runtime, options = {}) {
-  const deletedRoot = resolve44(runtime.supervisorRoot, "beeline", "deleted-runtimes");
-  const target = resolve44(deletedRoot, `${runtime.agent.publicKey}-${Date.now()}`);
+  const deletedRoot = resolve45(runtime.supervisorRoot, "beeline", "deleted-runtimes");
+  const target = resolve45(deletedRoot, `${runtime.agent.publicKey}-${Date.now()}`);
   return relocateAgentRuntime(runtime, target, {
     ...options.run ? { run: options.run } : {}
   });
 }
 async function relocateAgentRuntime(runtime, target, options = {}) {
   const source = runtimeDirectory(runtime.supervisorRoot, runtime.agent.publicKey);
-  const destination = resolve44(target);
+  const destination = resolve45(target);
   if (destination === source || destination.startsWith(`${source}/`)) {
     throw new Error("agent runtime destination must be outside the live runtime");
   }
@@ -49487,8 +49748,8 @@ async function relocateAgentRuntime(runtime, target, options = {}) {
 init_systemd();
 
 // apps/body/dist/release-status.js
-import { readFile as readFile33, readdir as readdir14, rename as rename13, writeFile as writeFile22 } from "node:fs/promises";
-import { resolve as resolve45 } from "node:path";
+import { readFile as readFile34, readdir as readdir15, rename as rename13, writeFile as writeFile22 } from "node:fs/promises";
+import { resolve as resolve46 } from "node:path";
 var DAEMON_RELEASE_STATUS_FILE = "release-status.json";
 var RELEASE_VERSION = /^v\d+\.\d+\.\d+$/;
 var SOURCE_SHA = /^[0-9a-f]{7,64}$/;
@@ -49505,7 +49766,7 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
     pid: options.pid ?? process.pid,
     readyAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
   };
-  const target = resolve45(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
+  const target = resolve46(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
   const temporary = `${target}.${status.pid}.tmp`;
   await writeFile22(temporary, `${JSON.stringify(status, null, 2)}
 `, { mode: 384 });
@@ -49514,8 +49775,8 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
 }
 
 // apps/body/dist/scratch-sweep.js
-import { lstat as lstat10, readdir as readdir15, rmdir as rmdir3, unlink as unlink9 } from "node:fs/promises";
-import { resolve as resolve46 } from "node:path";
+import { lstat as lstat11, readdir as readdir16, rmdir as rmdir3, unlink as unlink9 } from "node:fs/promises";
+import { resolve as resolve47 } from "node:path";
 var DEFAULT_SCRATCH_TTL_HOURS = 72;
 var NEVER_SWEEP_SUBDIR_NAMES = new Set(HOME_SUBDIRS.filter((name) => name !== "tmp"));
 function scratchTtlMs(env = process.env) {
@@ -49524,10 +49785,10 @@ function scratchTtlMs(env = process.env) {
   return (Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_SCRATCH_TTL_HOURS) * 60 * 60 * 1e3;
 }
 async function discoverAttachScratchRoots(runtimeDir) {
-  const roomsDir = resolve46(runtimeDir, "rooms");
+  const roomsDir = resolve47(runtimeDir, "rooms");
   let entries;
   try {
-    entries = await readdir15(roomsDir, { withFileTypes: true });
+    entries = await readdir16(roomsDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -49535,8 +49796,8 @@ async function discoverAttachScratchRoots(runtimeDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const home = resolve46(roomsDir, entry.name, "agent-home");
-    const stats = await lstat10(home).catch(() => void 0);
+    const home = resolve47(roomsDir, entry.name, "agent-home");
+    const stats = await lstat11(home).catch(() => void 0);
     if (stats?.isDirectory())
       roots.push(home);
   }
@@ -49545,7 +49806,7 @@ async function discoverAttachScratchRoots(runtimeDir) {
 async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
   let entries;
   try {
-    entries = await readdir15(dir, { withFileTypes: true });
+    entries = await readdir16(dir, { withFileTypes: true });
   } catch {
     return { removedFiles: 0, removedBytes: 0 };
   }
@@ -49554,15 +49815,15 @@ async function removeStaleFiles(dir, cutoffMs, protectNamesHere) {
   for (const entry of entries) {
     if (protectNamesHere && NEVER_SWEEP_SUBDIR_NAMES.has(entry.name))
       continue;
-    const path = resolve46(dir, entry.name);
-    const stats = await lstat10(path).catch(() => void 0);
+    const path = resolve47(dir, entry.name);
+    const stats = await lstat11(path).catch(() => void 0);
     if (!stats || stats.isSymbolicLink())
       continue;
     if (stats.isDirectory()) {
       const nested = await removeStaleFiles(path, cutoffMs, false);
       removedFiles += nested.removedFiles;
       removedBytes += nested.removedBytes;
-      const remaining = await readdir15(path).catch(() => void 0);
+      const remaining = await readdir16(path).catch(() => void 0);
       if (remaining && remaining.length === 0)
         await rmdir3(path).catch(() => void 0);
       continue;
@@ -49580,7 +49841,7 @@ async function sweepAttachScratchRoots(roots, ttlMs, now2 = Date.now()) {
   let removedFiles = 0;
   let removedBytes = 0;
   for (const root of roots) {
-    const stats = await lstat10(root).catch(() => void 0);
+    const stats = await lstat11(root).catch(() => void 0);
     if (!stats?.isDirectory())
       continue;
     const result = await removeStaleFiles(root, cutoffMs, true);
@@ -49624,7 +49885,7 @@ async function runAgentRuntime(configPath, host, signal) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve47(runtimeDir, "workspace"),
+    workspaceRoot: resolve48(runtimeDir, "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -49759,7 +50020,6 @@ async function runAgentRuntime(configPath, host, signal) {
       host.notifyReleaseAvailable(`${version}:${sha}`);
       void host.tickUpdate();
     });
-    daemonApi.onLiveOpen(() => void host.tickUpdate());
     core.setInteractiveIdleListener(() => {
       void host.tickUpdate();
     });
@@ -49891,26 +50151,26 @@ init_squire_host();
 
 // apps/body/dist/host-disk-retention.js
 import { execFile as execFile20 } from "node:child_process";
-import { lstat as lstat11, readdir as readdir16, rm as rm21 } from "node:fs/promises";
-import { join as join23, resolve as resolve48 } from "node:path";
+import { lstat as lstat12, readdir as readdir17, rm as rm21 } from "node:fs/promises";
+import { join as join23, resolve as resolve49 } from "node:path";
 import { promisify as promisify14 } from "node:util";
 var execFileAsync14 = promisify14(execFile20);
 var DELETED_RUNTIME_TTL_MS = 30 * 24 * 60 * 6e4;
 var REPOSITORY_CACHE_TTL_MS = 30 * 24 * 60 * 6e4;
 async function pruneDeletedRuntimes(supervisorRoot2, now2 = Date.now()) {
-  const root = resolve48(supervisorRoot2, "beeline", "deleted-runtimes");
+  const root = resolve49(supervisorRoot2, "beeline", "deleted-runtimes");
   const removed = [];
-  for (const entry of await readdir16(root, { withFileTypes: true }).catch(() => [])) {
+  for (const entry of await readdir17(root, { withFileTypes: true }).catch(() => [])) {
     const match = /^([a-f0-9]{64})-(\d{13})$/.exec(entry.name);
     if (!entry.isDirectory() || !match || now2 - Number(match[2]) < DELETED_RUNTIME_TTL_MS)
       continue;
     const path = join23(root, entry.name);
-    if (!(await lstat11(path)).isDirectory())
+    if (!(await lstat12(path)).isDirectory())
       continue;
-    const rooms = resolve48(path, "rooms");
+    const rooms = resolve49(path, "rooms");
     let retainsHome = false;
-    for (const room of await readdir16(rooms).catch(() => [])) {
-      const home = await lstat11(resolve48(rooms, room, "agent-home")).catch(() => void 0);
+    for (const room of await readdir17(rooms).catch(() => [])) {
+      const home = await lstat12(resolve49(rooms, room, "agent-home")).catch(() => void 0);
       if (home) {
         retainsHome = true;
         break;
@@ -49924,19 +50184,19 @@ async function pruneDeletedRuntimes(supervisorRoot2, now2 = Date.now()) {
   return removed;
 }
 async function pruneRepositoryCaches(supervisorRoot2, now2 = Date.now()) {
-  const root = resolve48(supervisorRoot2, "beeline", "repositories");
+  const root = resolve49(supervisorRoot2, "beeline", "repositories");
   const removed = [];
-  for (const entry of await readdir16(root, { withFileTypes: true }).catch(() => [])) {
+  for (const entry of await readdir17(root, { withFileTypes: true }).catch(() => [])) {
     if (!entry.isDirectory() || !/^[a-f0-9]{24}\.git$/.test(entry.name))
       continue;
     const path = join23(root, entry.name);
-    const info = await lstat11(path);
+    const info = await lstat12(path);
     if (!info.isDirectory() || now2 - info.mtimeMs < REPOSITORY_CACHE_TTL_MS)
       continue;
     const listing = await execFileAsync14("git", [`--git-dir=${path}`, "worktree", "list", "--porcelain"]).then((result) => result.stdout, () => void 0);
     if (listing === void 0)
       continue;
-    const attached = listing.split("\n").some((line) => line.startsWith("worktree ") && resolve48(line.slice("worktree ".length)) !== path);
+    const attached = listing.split("\n").some((line) => line.startsWith("worktree ") && resolve49(line.slice("worktree ".length)) !== path);
     if (attached)
       continue;
     const refs = await execFileAsync14("git", [
@@ -50002,7 +50262,7 @@ async function runMachineHelper(options = {}) {
     diskSweepRunning = true;
     try {
       const modelDue = now2 - lastModelSweepAt >= 60 * 6e4;
-      const removed = modelDue ? await pruneSharedModelCache(resolve49(supervisorRoot2, "beeline", "model-cache")) : [];
+      const removed = modelDue ? await pruneSharedModelCache(resolve50(supervisorRoot2, "beeline", "model-cache")) : [];
       if (modelDue)
         lastModelSweepAt = now2;
       if (now2 - lastRetentionSweepAt >= 24 * 60 * 6e4) {
@@ -50145,7 +50405,11 @@ async function runMachineHelper(options = {}) {
   const machineKey = () => [...slots.values()].map((slot) => slot.agentId).sort()[0] ?? "helper";
   if (layout) {
     update = await ManagedUpdateHandoff.create(layout, Date.now, {
-      env
+      env,
+      ...options.runUpdateWorker ? { runUpdateWorker: options.runUpdateWorker } : {},
+      onWorkerSettled: () => {
+        void tickUpdate();
+      }
     });
   }
   const recoverManagedRestart = (error) => {
@@ -50191,7 +50455,13 @@ async function runMachineHelper(options = {}) {
     machineLink: (baseUrl) => {
       let link2 = links.get(baseUrl);
       if (!link2) {
-        link2 = new MachineLink({ baseUrl });
+        link2 = new MachineLink({
+          baseUrl,
+          onRegistered: () => {
+            update?.reconcileOnConnect();
+            void tickUpdate();
+          }
+        });
         link2.setHelperIdentity({
           releaseVersion: loadedReleaseIdentity?.version,
           sourceSha: loadedReleaseIdentity?.commit
@@ -50318,7 +50588,12 @@ async function runMachineHelper(options = {}) {
     void rescan().catch((error) => console.error("[helper] rescan failed:", error));
   };
   signals.on("SIGHUP", onHangup);
-  const stopWatchdog = startLocalWatchdog(notifier, statusLine);
+  const stopWatchdog = startLocalWatchdog(notifier, statusLine, async () => {
+    if ([...slots.values()].some((slot) => slot.running && !slot.controller.signal.aborted && !hosted.has(slot.agentId)))
+      return false;
+    await Promise.all([...hosted.values()].map((agent) => agent.core.requestWorkLoopProgress()));
+    return true;
+  }, void 0, env);
   try {
     console.log(`[helper] hosting ${initial.length} agent(s) on one machine socket per server`);
     for (const configPath of initial)
@@ -50404,10 +50679,10 @@ function sleep3(ms, signal) {
 // apps/body/dist/android-emulator-lease.js
 import { execFileSync, spawn as spawn14 } from "node:child_process";
 import { randomUUID as randomUUID15 } from "node:crypto";
-import { cp as cp2, mkdir as mkdir31, open as open6, readFile as readFile34, rm as rm22, stat as stat13, writeFile as writeFile24 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir31, open as open6, readFile as readFile35, rm as rm22, stat as stat13, writeFile as writeFile24 } from "node:fs/promises";
 import { createServer as createServer5 } from "node:net";
 import { existsSync as existsSync11 } from "node:fs";
-import { resolve as resolve50 } from "node:path";
+import { resolve as resolve51 } from "node:path";
 var FIRST_PORT = 5554;
 var LAST_PORT = 5584;
 var PORT_STEP = 4;
@@ -50420,7 +50695,7 @@ function processAlive(pid) {
   }
 }
 async function processStart(pid) {
-  const raw = await readFile34(`/proc/${pid}/stat`, "utf8").catch(() => void 0);
+  const raw = await readFile35(`/proc/${pid}/stat`, "utf8").catch(() => void 0);
   if (raw)
     return raw.slice(raw.lastIndexOf(")") + 2).split(" ")[19];
   try {
@@ -50437,13 +50712,13 @@ async function portFree(port) {
   });
 }
 async function leaseEmulator(root, privateRoot) {
-  const absolute = resolve50(root);
+  const absolute = resolve51(root);
   await Promise.all([
     mkdir31(absolute, { recursive: true, mode: 448 }),
     mkdir31(privateRoot, { recursive: true, mode: 448 })
   ]);
   for (let port = FIRST_PORT; port <= LAST_PORT; port += PORT_STEP) {
-    const marker = resolve50(absolute, `port-${port}.lease`);
+    const marker = resolve51(absolute, `port-${port}.lease`);
     let handle2;
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
@@ -50452,7 +50727,7 @@ async function leaseEmulator(root, privateRoot) {
       } catch (error) {
         if (error.code !== "EEXIST")
           throw error;
-        const old = await readFile34(marker, "utf8").catch(() => "");
+        const old = await readFile35(marker, "utf8").catch(() => "");
         const [pidText, start] = old.split(":");
         const pid = Number(pidText);
         if (Number.isSafeInteger(pid) && pid > 0 && processAlive(pid)) {
@@ -50466,20 +50741,20 @@ async function leaseEmulator(root, privateRoot) {
         if (!before || !await portFree(port) || !await portFree(port + 1) || !await portFree(port + 2))
           break;
         const after = await stat13(marker).catch(() => void 0);
-        if (after && before.ino === after.ino && await readFile34(marker, "utf8").catch(() => "") === old)
+        if (after && before.ino === after.ino && await readFile35(marker, "utf8").catch(() => "") === old)
           await rm22(marker, { force: true });
       }
     }
     if (!handle2)
       continue;
-    const instance = resolve50(privateRoot, `instance-${randomUUID15()}`);
+    const instance = resolve51(privateRoot, `instance-${randomUUID15()}`);
     const ownership = `${process.pid}:${await processStart(process.pid)}:${randomUUID15()}:${instance}`;
     try {
       await handle2.writeFile(ownership);
       await handle2.sync();
       if (!await portFree(port) || !await portFree(port + 1) || !await portFree(port + 2)) {
         await handle2.close();
-        if (await readFile34(marker, "utf8").catch(() => "") === ownership)
+        if (await readFile35(marker, "utf8").catch(() => "") === ownership)
           await rm22(marker, { force: true });
         continue;
       }
@@ -50490,14 +50765,14 @@ async function leaseEmulator(root, privateRoot) {
         serial: `emulator-${port}`,
         root: instance,
         release: async () => {
-          if (await readFile34(marker, "utf8").catch(() => "") === ownership)
+          if (await readFile35(marker, "utf8").catch(() => "") === ownership)
             await rm22(marker, { force: true });
           await rm22(instance, { recursive: true, force: true });
         }
       };
     } catch (error) {
       await handle2.close().catch(() => void 0);
-      if (await readFile34(marker, "utf8").catch(() => "") === ownership)
+      if (await readFile35(marker, "utf8").catch(() => "") === ownership)
         await rm22(marker, { force: true });
       throw error;
     }
@@ -50522,19 +50797,19 @@ async function runLeasedEmulator(args, env = process.env) {
     if (env.ANDROID_EMULATOR_HOME)
       await mkdir31(env.ANDROID_EMULATOR_HOME, { recursive: true, mode: 448 });
     if (env.ANDROID_HOME) {
-      const adb = resolve50(env.ANDROID_HOME, "platform-tools/adb");
+      const adb = resolve51(env.ANDROID_HOME, "platform-tools/adb");
       if (existsSync11(adb))
         execFileSync(adb, ["start-server"], { env, timeout: 15e3 });
     }
-    const original = resolve50(baseAvdHome, `${avdName}.avd`);
-    const localAvdHome = resolve50(lease.root, "avd");
-    const local = resolve50(localAvdHome, `${avdName}.avd`);
-    const data = resolve50(lease.root, "data");
+    const original = resolve51(baseAvdHome, `${avdName}.avd`);
+    const localAvdHome = resolve51(lease.root, "avd");
+    const local = resolve51(localAvdHome, `${avdName}.avd`);
+    const data = resolve51(lease.root, "data");
     await mkdir31(local, { recursive: true, mode: 448 });
     await mkdir31(data, { recursive: true, mode: 448 });
-    await cp2(resolve50(original, "config.ini"), resolve50(local, "config.ini"));
-    const metadata = await readFile34(resolve50(baseAvdHome, `${avdName}.ini`), "utf8");
-    await writeFile24(resolve50(localAvdHome, `${avdName}.ini`), metadata.replace(/^path\s*=.*$/m, `path=${local}`).replace(/^path\.rel\s*=.*\n?/m, ""), { mode: 384 });
+    await cp2(resolve51(original, "config.ini"), resolve51(local, "config.ini"));
+    const metadata = await readFile35(resolve51(baseAvdHome, `${avdName}.ini`), "utf8");
+    await writeFile24(resolve51(localAvdHome, `${avdName}.ini`), metadata.replace(/^path\s*=.*$/m, `path=${local}`).replace(/^path\.rel\s*=.*\n?/m, ""), { mode: 384 });
     const status = await new Promise((done, reject) => {
       const child = spawn14(emulator, [...args.filter((arg) => arg !== "-read-only"), "-port", String(lease.port), "-datadir", data], {
         env: { ...env, ANDROID_AVD_HOME: localAvdHome, ADB_EMU: "0" },
@@ -50651,7 +50926,7 @@ async function main() {
     const roomId = roomFlag >= 0 ? args[roomFlag + 1] : void 0;
     if (!configPath || !roomId)
       throw new Error("corner-read-token requires --config and --room");
-    const activated = await activateDaemonTransport(resolve51(configPath));
+    const activated = await activateDaemonTransport(resolve52(configPath));
     if (!activated)
       throw new Error("corner-read-token requires monolith transport");
     const credential = await activated.client.execute("getRoomGitHubToken", { roomId });
@@ -50706,7 +50981,7 @@ async function main() {
     }
     if (!configPath && !args.includes("--machine"))
       throw new Error("daemon requires --machine, or --config <runtime.json> for one agent");
-    const { reason, lifecycle } = await runMachineHelper(configPath ? { configPaths: [resolve51(configPath)] } : {});
+    const { reason, lifecycle } = await runMachineHelper(configPath ? { configPaths: [resolve52(configPath)] } : {});
     daemonLifecycle = lifecycle;
     lifecycle.exit(reason);
     return;