claude-use 11.48.0 → 11.49.0

package/dist/index.cjs

@@ -2452,8 +2452,8 @@ var init_lock = __esm({
 });
 
 // src/launcher/farm.ts
-function readFarmManifest(fs13, farmRoot) {
-  const raw = fs13.readFileUtf8(import_node_path7.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs13.readFileUtf8(import_node_path7.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs14, farmRoot) {
+  const raw = fs14.readFileUtf8(import_node_path7.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs14.readFileUtf8(import_node_path7.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -2511,9 +2511,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs13, root, rel) {
+function listSubtree(fs14, root, rel) {
   const absolute = import_node_path7.default.join(root, rel);
-  const stat = fs13.lstat(absolute);
+  const stat = fs14.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -2521,10 +2521,10 @@ function listSubtree(fs13, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs13.readdir(absolute)].sort().flatMap((name) => listSubtree(fs13, root, `${rel}/${name}`));
+    const children = [...fs14.readdir(absolute)].sort().flatMap((name) => listSubtree(fs14, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs13.hashFile(absolute);
+  const contentHash = fs14.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -2538,25 +2538,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs13, farmRoot, manifest) {
+function reconciliationScope(fs14, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs13.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs13.lstat(import_node_path7.default.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs14.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs14.lstat(import_node_path7.default.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs13, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs13, farmRoot, root));
+function collectFarmListing(fs14, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs14, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs13, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs14, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = import_node_path7.default.join(claudeHome, entry.rel);
-    const stat = fs13.lstat(absolute);
+    const stat = fs14.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs13.hashFile(absolute);
+      const contentHash = fs14.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -3327,10 +3327,10 @@ var init_route = __esm({
 });
 
 // src/frontdoor/state.ts
-function readFrontDoorState(fs13, stateFile) {
+function readFrontDoorState(fs14, stateFile) {
   let raw;
   try {
-    raw = fs13.readFileUtf8(stateFile);
+    raw = fs14.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -3344,9 +3344,9 @@ function readFrontDoorState(fs13, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs13, stateFile, state) {
-  fs13.mkdirp(import_node_path8.default.dirname(stateFile));
-  fs13.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs14, stateFile, state) {
+  fs14.mkdirp(import_node_path8.default.dirname(stateFile));
+  fs14.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function directOrigin(port) {
@@ -3356,27 +3356,37 @@ function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : directOrigin(port);
 }
-function writeFrontDoorDirectRecord(fs13, recordsDir, record) {
-  fs13.mkdirp(recordsDir);
-  fs13.writeFilePrivate(import_node_path8.default.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
+function writeFrontDoorDirectRecord(fs14, recordsDir, record) {
+  fs14.mkdirp(recordsDir);
+  fs14.writeFilePrivate(import_node_path8.default.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
 `);
 }
-function removeFrontDoorDirectRecord(fs13, recordsDir, pid) {
-  fs13.removeRecursive(import_node_path8.default.join(recordsDir, `${String(pid)}.json`));
+function removeFrontDoorDirectRecord(fs14, recordsDir, pid) {
+  fs14.removeRecursive(import_node_path8.default.join(recordsDir, `${String(pid)}.json`));
+}
+function markFrontDoorDraining(fs14, markersDir, pid) {
+  fs14.mkdirp(markersDir);
+  fs14.writeFilePrivate(import_node_path8.default.join(markersDir, String(pid)), "\n");
+}
+function unmarkFrontDoorDraining(fs14, markersDir, pid) {
+  fs14.removeRecursive(import_node_path8.default.join(markersDir, String(pid)));
+}
+function listDrainingFrontDoors(fs14, markersDir, isRunning) {
+  return fs14.readdir(markersDir).flatMap((file) => /^[1-9]\d*$/.test(file) && Number.isSafeInteger(Number(file)) ? [Number(file)] : []).filter(isRunning).sort((a, b) => a - b);
 }
 function recordPid(file) {
   const pidText = /^([1-9]\d*)\.json$/.exec(file)?.[1];
   const pid = pidText === void 0 ? void 0 : Number(pidText);
   return pid !== void 0 && Number.isSafeInteger(pid) ? pid : void 0;
 }
-function readDirectRecordEntry(fs13, recordsDir, file) {
+function readDirectRecordEntry(fs14, recordsDir, file) {
   const pid = recordPid(file);
   if (pid === void 0) {
     return void 0;
   }
   let raw;
   try {
-    raw = fs13.readFileUtf8(import_node_path8.default.join(recordsDir, file));
+    raw = fs14.readFileUtf8(import_node_path8.default.join(recordsDir, file));
   } catch {
     return void 0;
   }
@@ -3390,47 +3400,47 @@ function readDirectRecordEntry(fs13, recordsDir, file) {
     return { malformed: true };
   }
 }
-function listFrontDoorDirectRecords(fs13, recordsDir) {
-  return fs13.readdir(recordsDir).flatMap((file) => {
-    const entry = readDirectRecordEntry(fs13, recordsDir, file);
+function listFrontDoorDirectRecords(fs14, recordsDir) {
+  return fs14.readdir(recordsDir).flatMap((file) => {
+    const entry = readDirectRecordEntry(fs14, recordsDir, file);
     return entry?.record === void 0 ? [] : [entry.record];
   }).sort((a, b) => a.pid - b.pid);
 }
-function pruneMalformedFrontDoorDirectFiles(fs13, recordsDir, isRunning) {
-  for (const file of fs13.readdir(recordsDir)) {
+function pruneMalformedFrontDoorDirectFiles(fs14, recordsDir, isRunning) {
+  for (const file of fs14.readdir(recordsDir)) {
     const writer = RECORD_TEMPORARY_FILE.exec(file)?.[1];
     const stale = writer !== void 0 && !isRunning(Number(writer));
-    if (stale || readDirectRecordEntry(fs13, recordsDir, file)?.malformed === true) {
-      fs13.removeRecursive(import_node_path8.default.join(recordsDir, file));
+    if (stale || readDirectRecordEntry(fs14, recordsDir, file)?.malformed === true) {
+      fs14.removeRecursive(import_node_path8.default.join(recordsDir, file));
     }
   }
 }
 function liveFrontDoorDirectRecords(records, liveness) {
   return records.filter((record) => liveness.doors.has(record.pid) || liveness.unknown.has(record.pid));
 }
-function pruneDeadFrontDoorDirectRecords(fs13, recordsDir, records, liveness) {
+function pruneDeadFrontDoorDirectRecords(fs14, recordsDir, records, liveness) {
   for (const record of records) {
     if (!liveness.doors.has(record.pid) && !liveness.unknown.has(record.pid)) {
-      removeFrontDoorDirectRecord(fs13, recordsDir, record.pid);
+      removeFrontDoorDirectRecord(fs14, recordsDir, record.pid);
     }
   }
 }
 function recordOf(details) {
   return details === void 0 ? {} : { sessionId: details.sessionId, ...details.models === void 0 ? {} : { models: details.models } };
 }
-function writeFrontDoorSession(fs13, sessionsDir, session) {
-  fs13.mkdirPrivate(sessionsDir);
-  fs13.writeFilePrivate(import_node_path8.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs14, sessionsDir, session) {
+  fs14.mkdirPrivate(sessionsDir);
+  fs14.writeFilePrivate(import_node_path8.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs13, sessionsDir) {
+function listFrontDoorSessions(fs14, sessionsDir) {
   const sessions = [];
-  for (const name of fs13.readdir(sessionsDir)) {
+  for (const name of fs14.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs13.readFileUtf8(import_node_path8.default.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs14.readFileUtf8(import_node_path8.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt, ...parsed.data.supervisorPid === void 0 ? {} : { supervisorPid: parsed.data.supervisorPid } });
       }
@@ -3440,14 +3450,14 @@ function listFrontDoorSessions(fs13, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs13, sessionsDir, pid) {
-  fs13.removeRecursive(import_node_path8.default.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs14, sessionsDir, pid) {
+  fs14.removeRecursive(import_node_path8.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs13, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs14, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs13, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs14, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs13, sessionsDir, session.pid);
+      removeFrontDoorSession(fs14, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -3545,9 +3555,9 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
   }
 }
 async function serveFrontDoor(idleShutdownMinutes, ports, options) {
-  const { fs: fs13, paths } = ports;
+  const { fs: fs14, paths } = ports;
   const servingBinary = ports.statOwnExecutable();
-  const previous = readFrontDoorState(fs13, paths.frontdoorStateFile);
+  const previous = readFrontDoorState(fs14, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -3558,12 +3568,12 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   });
   const fail = (message) => {
     ports.closeRcStreamHub();
-    writeFrontDoorState(fs13, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs13.removeRecursive(paths.frontdoorLockFile);
+    writeFrontDoorState(fs14, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs14.removeRecursive(paths.frontdoorLockFile);
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs13, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs14, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http3;
   try {
@@ -3603,16 +3613,16 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom admits the new address once its supervisor rewrites the allowlist file)`);
   }
   lastDirectPort = direct.port;
-  writeFrontDoorDirectRecord(fs13, paths.frontdoorDirectRecordsDir, { pid: ports.ownPid, directPort: direct.port });
-  writeFrontDoorState(fs13, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http3.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
+  writeFrontDoorDirectRecord(fs14, paths.frontdoorDirectRecordsDir, { pid: ports.ownPid, directPort: direct.port });
+  writeFrontDoorState(fs14, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http3.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
   ports.doorHealth.generation({ providerPort: http3.port, connectPort: connect3.port, directPort: direct.port });
-  fs13.removeRecursive(paths.frontdoorLockFile);
+  fs14.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http3.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   const watchdog = ports.startWatchdog?.();
   let idleSince;
   let ticks = 0;
   const supersedingOwner = () => {
-    const owner = readFrontDoorState(fs13, paths.frontdoorStateFile)?.supervisorPid;
+    const owner = readFrontDoorState(fs14, paths.frontdoorStateFile)?.supervisorPid;
     return owner !== void 0 && owner !== ports.ownPid && ports.isRunning(owner) ? owner : void 0;
   };
   let supersededBy;
@@ -3621,30 +3631,61 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     const current = ports.statOwnExecutable();
     return current !== void 0 && servingBinary !== void 0 && (current.dev !== servingBinary.dev || current.ino !== servingBinary.ino || current.size !== servingBinary.size || current.mtimeMs !== servingBinary.mtimeMs);
   };
+  const pause = async () => {
+    await new Promise((resolve) => {
+      const wake = () => {
+        resolve();
+      };
+      ports.retire?.addEventListener("abort", wake, { once: true });
+      void ports.sleep(FRONTDOOR_POLL_MS).then(() => {
+        ports.retire?.removeEventListener("abort", wake);
+        resolve();
+      });
+    });
+  };
+  const retireByDrain = async () => {
+    ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: asked to exit; releasing the front door's addresses and finishing the connections it carries`);
+    watchdog?.stop();
+    ports.stopBackgroundWork?.();
+    const drained = [direct.drain(), connect3.drain(), http3.drain()];
+    if (supersedingOwner() === void 0) {
+      writeFrontDoorState(fs14, paths.frontdoorStateFile, sticky());
+    }
+    markFrontDoorDraining(fs14, paths.frontdoorDrainingDir, ports.ownPid);
+    ports.closeRcStreamHub();
+    await Promise.all(drained);
+    unmarkFrontDoorDraining(fs14, paths.frontdoorDrainingDir, ports.ownPid);
+    removeFrontDoorDirectRecord(fs14, paths.frontdoorDirectRecordsDir, ports.ownPid);
+    ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: the connections this door carried have ended; exiting`);
+    return 0;
+  };
   const closeServing = async () => {
     watchdog?.stop();
     await direct.close();
     await connect3.close();
     await http3.close();
     ports.closeRcStreamHub();
-    removeFrontDoorDirectRecord(fs13, paths.frontdoorDirectRecordsDir, ports.ownPid);
+    removeFrontDoorDirectRecord(fs14, paths.frontdoorDirectRecordsDir, ports.ownPid);
   };
   const shutdown = async () => {
     await closeServing();
     if (supersedingOwner() === void 0) {
-      writeFrontDoorState(fs13, paths.frontdoorStateFile, sticky());
+      writeFrontDoorState(fs14, paths.frontdoorStateFile, sticky());
     }
     return 0;
   };
   for (; ; ) {
     watchdog?.beat();
+    if (ports.retire?.aborted === true) {
+      return await retireByDrain();
+    }
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
       watchdog?.stop();
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    const listed = listFrontDoorSessions(fs13, paths.frontdoorSessionsDir);
-    const pruned = pruneDeadFrontDoorSessions(fs13, paths.frontdoorSessionsDir, ports.isRunning);
+    const listed = listFrontDoorSessions(fs14, paths.frontdoorSessionsDir);
+    const pruned = pruneDeadFrontDoorSessions(fs14, paths.frontdoorSessionsDir, ports.isRunning);
     ports.observeLaunchRegistry(listed, pruned);
     ports.checkQuotaExpiry();
     const prunedPids = new Set(pruned);
@@ -3654,7 +3695,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
       if (supersededBy !== void 0) {
         ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: supervisor ${String(supersededBy)} now owns the front door; taking no new sessions and exiting once the sessions this door serves have ended`);
         ports.doorHealth.superseded(supersededBy);
-        await ports.sleep(FRONTDOOR_POLL_MS);
+        await pause();
         continue;
       }
     } else {
@@ -3666,7 +3707,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
         await closeServing();
         return 0;
       }
-      await ports.sleep(FRONTDOOR_POLL_MS);
+      await pause();
       continue;
     }
     if (live.length === 0) {
@@ -3684,7 +3725,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     } else {
       idleSince = void 0;
     }
-    await ports.sleep(FRONTDOOR_POLL_MS);
+    await pause();
   }
 }
 var import_node_path9, FRONTDOOR_SUPERVISOR_STILL_RUNNING, FRONTDOOR_POLL_MS, MS_PER_MINUTE;
@@ -3837,25 +3878,35 @@ ${request4.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `$
   const transparent = config.transparentPort === void 0 || apiSession === void 0 ? void 0 : await effects.listenLoopback(config.transparentPort, (socket) => {
     sniAcceptor.accept(socket);
   });
+  const closeSurface = async () => {
+    ledger.close();
+    await listener.close();
+    await transparent?.close();
+    sniAcceptor.close();
+    for (const { httpSession, tlsAcceptor } of sessions) {
+      tlsAcceptor.close();
+      httpSession?.close();
+    }
+  };
   return {
     port: listener.port,
     ...transparent === void 0 ? {} : { transparentPort: transparent.port },
-    close: async () => {
-      ledger.close();
-      await listener.close();
+    openTunnels: ledger.openTunnels,
+    drain: async () => {
+      listener.stopAccepting();
       await transparent?.close();
-      sniAcceptor.close();
-      for (const { httpSession, tlsAcceptor } of sessions) {
-        tlsAcceptor.close();
-        httpSession?.close();
-      }
-    }
+      await ledger.retire();
+      await closeSurface();
+    },
+    close: closeSurface
   };
 }
 function createConnectionLedger(limits, isLiveCapability2) {
   const pending = /* @__PURE__ */ new Map();
   const authenticated = /* @__PURE__ */ new Map();
   let tunnels = 0;
+  const blind = /* @__PURE__ */ new Set();
+  let onNoBlindTunnels;
   const leavePending = (socket) => {
     const deadline = pending.get(socket);
     if (deadline !== void 0) {
@@ -3892,16 +3943,45 @@ function createConnectionLedger(limits, isLiveCapability2) {
       });
     },
     headReceived: leavePending,
-    establish: (socket, capability) => {
+    openTunnels: () => tunnels,
+    retire: async () => {
+      for (const socket of pending.keys()) {
+        socket.destroy();
+      }
+      for (const deadline of pending.values()) {
+        clearTimeout(deadline);
+      }
+      pending.clear();
+      for (const sockets of authenticated.values()) {
+        for (const socket of sockets) {
+          if (!blind.has(socket)) {
+            socket.destroy();
+          }
+        }
+      }
+      if (blind.size > 0) {
+        await new Promise((resolve) => {
+          onNoBlindTunnels = resolve;
+        });
+      }
+    },
+    establish: (socket, capability, kind) => {
       if (tunnels >= limits.maxTunnels) {
         return false;
       }
       tunnels += 1;
+      if (kind === "blind") {
+        blind.add(socket);
+      }
       const sockets = authenticated.get(capability) ?? /* @__PURE__ */ new Set();
       sockets.add(socket);
       authenticated.set(capability, sockets);
       socket.once("close", () => {
         tunnels -= 1;
+        blind.delete(socket);
+        if (blind.size === 0) {
+          onNoBlindTunnels?.();
+        }
         sockets.delete(socket);
         if (sockets.size === 0 && authenticated.get(capability) === sockets) {
           authenticated.delete(capability);
@@ -3983,11 +4063,11 @@ function routeConnect(socket, head, context) {
     refuse(socket, REFUSAL.badRequest);
     return;
   }
-  if (!ledger.establish(socket, capability)) {
+  const session = sessions.find((entry) => entry.host === target.host);
+  if (!ledger.establish(socket, capability, session === void 0 ? "blind" : "terminated")) {
     refuse(socket, REFUSAL.serviceUnavailable);
     return;
   }
-  const session = sessions.find((entry) => entry.host === target.host);
   config.capture?.connect(target, session !== void 0);
   socket.write(CONNECT_ESTABLISHED);
   if (session !== void 0) {
@@ -4111,7 +4191,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.48.0",
+      version: "11.49.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -4316,43 +4396,43 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs13, stateFile) {
+function readHeadroomState(fs14, stateFile) {
   try {
-    return parseJson(fs13.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs14.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs13, stateFile, state) {
-  fs13.mkdirp(import_node_path11.default.dirname(stateFile));
-  fs13.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs14, stateFile, state) {
+  fs14.mkdirp(import_node_path11.default.dirname(stateFile));
+  fs14.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
-function resolveServingHeadroomState(fs13, files, isRunning) {
-  const current = readHeadroomState(fs13, files.stateFile);
+function resolveServingHeadroomState(fs14, files, isRunning) {
+  const current = readHeadroomState(fs14, files.stateFile);
   if (current !== void 0) {
     return { path: files.stateFile, state: current };
   }
-  const legacy = readHeadroomState(fs13, files.legacyStateFile);
+  const legacy = readHeadroomState(fs14, files.legacyStateFile);
   if (legacy?.supervisorPid !== void 0 && isRunning(legacy.supervisorPid)) {
     return { path: files.legacyStateFile, state: legacy };
   }
   return void 0;
 }
-function migrateHeadroomState(fs13, files, isRunning) {
-  const legacy = readHeadroomState(fs13, files.legacyStateFile);
+function migrateHeadroomState(fs14, files, isRunning) {
+  const legacy = readHeadroomState(fs14, files.legacyStateFile);
   const legacyLive = legacy?.supervisorPid !== void 0 && isRunning(legacy.supervisorPid);
-  const current = readHeadroomState(fs13, files.stateFile);
+  const current = readHeadroomState(fs14, files.stateFile);
   if (current !== void 0 || legacyLive) {
-    if (!legacyLive && fs13.readFileUtf8(files.legacyStateFile) !== void 0) {
-      fs13.removeRecursive(files.legacyStateFile);
+    if (!legacyLive && fs14.readFileUtf8(files.legacyStateFile) !== void 0) {
+      fs14.removeRecursive(files.legacyStateFile);
     }
     return;
   }
   if (legacy !== void 0) {
-    writeHeadroomState(fs13, files.stateFile, legacy);
+    writeHeadroomState(fs14, files.stateFile, legacy);
   }
-  fs13.removeRecursive(files.legacyStateFile);
+  fs14.removeRecursive(files.legacyStateFile);
 }
 function hashAllowlist(allowlist) {
   return (0, import_node_crypto6.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
@@ -4385,27 +4465,27 @@ function isAdmissibleUrl(entry) {
 function parseAllowlistFile(content) {
   return content.replace(/^\uFEFF/, "").replace(ALLOWLIST_FILE_COMMENT, "").split(ALLOWLIST_FILE_SEPARATORS).map((entry) => entry.replace(ALLOWLIST_SURROUNDING_WHITESPACE, "")).filter((entry) => entry !== "" && !ALLOWLIST_ENTRY_WHITESPACE.test(entry) && (entry.includes("://") ? isAdmissibleUrl(entry) : isBareHost(entry)));
 }
-function writeAllowlistFile(fs13, allowlistFile, allowlist) {
-  fs13.mkdirPrivate(import_node_path11.default.dirname(allowlistFile));
-  fs13.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
+function writeAllowlistFile(fs14, allowlistFile, allowlist) {
+  fs14.mkdirPrivate(import_node_path11.default.dirname(allowlistFile));
+  fs14.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
 }
-function pruneStaleAllowlistTemporaries(fs13, allowlistFile, isRunning) {
+function pruneStaleAllowlistTemporaries(fs14, allowlistFile, isRunning) {
   const prefix = `${import_node_path11.default.basename(allowlistFile)}.`;
-  for (const name of fs13.readdir(import_node_path11.default.dirname(allowlistFile))) {
+  for (const name of fs14.readdir(import_node_path11.default.dirname(allowlistFile))) {
     const writer = name.startsWith(prefix) ? /^([1-9]\d*)\.tmp$/.exec(name.slice(prefix.length))?.[1] : void 0;
     if (writer !== void 0 && !isRunning(Number(writer))) {
-      fs13.removeRecursive(import_node_path11.default.join(import_node_path11.default.dirname(allowlistFile), name));
+      fs14.removeRecursive(import_node_path11.default.join(import_node_path11.default.dirname(allowlistFile), name));
     }
   }
 }
-function readAllProviders(fs13, providersDir) {
+function readAllProviders(fs14, providersDir) {
   const result = [];
-  for (const name of fs13.readdir(providersDir)) {
+  for (const name of fs14.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs13.readFileUtf8(import_node_path11.default.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs14.readFileUtf8(import_node_path11.default.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -4415,22 +4495,22 @@ function readAllProviders(fs13, providersDir) {
   }
   return result;
 }
-function writeSession(fs13, sessionsDir, session) {
-  fs13.mkdirp(sessionsDir);
-  fs13.writeFileUtf8(import_node_path11.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs14, sessionsDir, session) {
+  fs14.mkdirp(sessionsDir);
+  fs14.writeFileUtf8(import_node_path11.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs13, sessionsDir, pid) {
-  fs13.removeRecursive(import_node_path11.default.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs14, sessionsDir, pid) {
+  fs14.removeRecursive(import_node_path11.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs13, sessionsDir) {
+function listSessions(fs14, sessionsDir) {
   const sessions = [];
-  for (const name of fs13.readdir(sessionsDir)) {
+  for (const name of fs14.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs13.readFileUtf8(import_node_path11.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs14.readFileUtf8(import_node_path11.default.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -4440,22 +4520,22 @@ function listSessions(fs13, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs13, sessionsDir, supervisorPid) {
-  return listSessions(fs13, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs14, sessionsDir, supervisorPid) {
+  return listSessions(fs14, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs13, sessionsDir, isRunning) {
+function pruneDeadSessions(fs14, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs13, sessionsDir)) {
+  for (const session of listSessions(fs14, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs13, sessionsDir, session.pid);
+      removeSession(fs14, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs13, lockFile) {
+function readStartLock(fs14, lockFile) {
   try {
-    return parseJson(fs13.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs14.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -4548,12 +4628,12 @@ function earlierReleaseAllowlistHash(providers, doorOrigin) {
   }
   return hashAllowlist([...entries].sort());
 }
-function earlierReleaseDaemon(fs13, paths, daemon) {
+function earlierReleaseDaemon(fs14, paths, daemon) {
   if (daemonIdentity(daemon.commandLine, daemon.socketPath) !== "earlier-release") {
     return void 0;
   }
-  const providers = readAllProviders(fs13, paths.providersDir).map((entry) => entry.provider);
-  const expected = earlierReleaseAllowlistHash(providers, frontDoorOrigin(readFrontDoorState(fs13, paths.frontdoorStateFile)));
+  const providers = readAllProviders(fs14, paths.providersDir).map((entry) => entry.provider);
+  const expected = earlierReleaseAllowlistHash(providers, frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile)));
   return { admitsServingDoor: daemon.recordedHash === expected };
 }
 var EARLIER_RELEASE_ALLOWLIST, EARLIER_RELEASE_ANTHROPIC_UPSTREAM;
@@ -4578,8 +4658,8 @@ function awaitingCause(daemonPid, identity, allowlistFile) {
   }
   return `the headroom supervisor has not written an allowlist admitting this launch's upstreams to ${allowlistFile} within ${String(HEADROOM_START_TIMEOUT_MS)}ms`;
 }
-function daemonAdmits(fs13, allowlistFile, recordedHash, required) {
-  const content = fs13.readFileUtf8(allowlistFile);
+function daemonAdmits(fs14, allowlistFile, recordedHash, required) {
+  const content = fs14.readFileUtf8(allowlistFile);
   if (content === void 0 || recordedHash === void 0) {
     return false;
   }
@@ -4842,7 +4922,7 @@ function verifyAllowlistFile(allowlistFile, ports) {
   const replaceable = fileStat === void 0 || fileStat.kind === "file" || fileStat.kind === "symlink";
   return { message: refusal2, repairable: replaceable };
 }
-function prepareHeadroomSocket(fs13, ports, paths, supervisorPid) {
+function prepareHeadroomSocket(fs14, ports, paths, supervisorPid) {
   const unsupported = platformRefusal(ports.platform);
   if (unsupported !== void 0) {
     return { refused: unsupported };
@@ -4857,18 +4937,18 @@ function prepareHeadroomSocket(fs13, ports, paths, supervisorPid) {
   if (ports.lstat(paths.headroomSocketDir)?.kind === "symlink") {
     return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
   }
-  fs13.mkdirPrivate(paths.headroomSocketDir);
+  fs14.mkdirPrivate(paths.headroomSocketDir);
   const refusal2 = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
   return refusal2 === void 0 ? { socketPath } : { refused: refusal2 };
 }
-function pruneStaleHeadroomSockets(fs13, paths, isRunning) {
+function pruneStaleHeadroomSockets(fs14, paths, isRunning) {
   const removed = [];
-  for (const name of fs13.readdir(paths.headroomSocketDir)) {
+  for (const name of fs14.readdir(paths.headroomSocketDir)) {
     const pid = HEADROOM_SOCKET_NAME.exec(name)?.[1];
     if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
       continue;
     }
-    fs13.removeRecursive(import_node_path12.default.join(paths.headroomSocketDir, name));
+    fs14.removeRecursive(import_node_path12.default.join(paths.headroomSocketDir, name));
     removed.push(name);
   }
   return removed;
@@ -4980,37 +5060,37 @@ function compareVersions2(a, b) {
   return 0;
 }
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs13, paths } = ports;
+  const { fs: fs14, paths } = ports;
   let config = initialConfig;
-  migrateHeadroomState(fs13, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning);
-  const previousState = resolveServingHeadroomState(fs13, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning)?.state;
+  migrateHeadroomState(fs14, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning);
+  const previousState = resolveServingHeadroomState(fs14, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning)?.state;
   if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
     ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
     return 0;
   }
   let installedSource = previousState?.installedSource;
   const ownsState = () => {
-    const owner = readHeadroomState(fs13, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs14, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs13, paths.headroomStateFile, state);
+    writeHeadroomState(fs14, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message })) {
-      fs13.removeRecursive(paths.headroomLockFile);
+      fs14.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
   };
   const syncAllowlistFile = (allowlist) => {
     try {
-      if (fs13.readFileUtf8(paths.headroomAllowlistFile) !== formatAllowlistFile(allowlist)) {
-        writeAllowlistFile(fs13, paths.headroomAllowlistFile, allowlist);
+      if (fs14.readFileUtf8(paths.headroomAllowlistFile) !== formatAllowlistFile(allowlist)) {
+        writeAllowlistFile(fs14, paths.headroomAllowlistFile, allowlist);
         ports.log(`agent-shim headroom supervisor: wrote allowlist [${allowlist.join(", ")}] to ${paths.headroomAllowlistFile}`);
       }
       return void 0;
@@ -5028,9 +5108,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     }
     ports.log(`agent-shim headroom supervisor: repairing the allowlist file: ${problem.message}`);
     try {
-      fs13.mkdirPrivate(paths.headroomDir);
-      fs13.mkdirPrivate(import_node_path13.default.dirname(paths.headroomAllowlistFile));
-      writeAllowlistFile(fs13, paths.headroomAllowlistFile, allowlist);
+      fs14.mkdirPrivate(paths.headroomDir);
+      fs14.mkdirPrivate(import_node_path13.default.dirname(paths.headroomAllowlistFile));
+      writeAllowlistFile(fs14, paths.headroomAllowlistFile, allowlist);
     } catch (error) {
       return `could not write the headroom allowlist file ${paths.headroomAllowlistFile}: ${error instanceof Error ? error.message : String(error)}`;
     }
@@ -5055,20 +5135,20 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     installedSource = config.source;
     return void 0;
   };
-  const socket = prepareHeadroomSocket(fs13, ports.socketTrust, paths, ports.ownPid);
+  const socket = prepareHeadroomSocket(fs14, ports.socketTrust, paths, ports.ownPid);
   if (socket.refused !== void 0) {
     return fail(socket.refused);
   }
   const { socketPath } = socket;
-  pruneStaleHeadroomSockets(fs13, paths, ports.isRunning);
-  pruneStaleAllowlistTemporaries(fs13, paths.headroomAllowlistFile, ports.isRunning);
+  pruneStaleHeadroomSockets(fs14, paths, ports.isRunning);
+  pruneStaleAllowlistTemporaries(fs14, paths.headroomAllowlistFile, ports.isRunning);
   const installFailure = ensureInstalled();
   if (installFailure !== void 0) {
     return fail(installFailure);
   }
   const version = ports.headroomVersion() ?? "unknown";
   writeOwnState({ supervisorPid: ports.ownPid, version, installedSource });
-  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${currentHeadroomAllowlistInputs(fs13, paths, ports.frontDoorLiveness).frontDoorOrigins.join(", ")}]`);
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${currentHeadroomAllowlistInputs(fs14, paths, ports.frontDoorLiveness).frontDoorOrigins.join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
   const orphanSocket = previousState?.socketPath ?? (previousState?.supervisorPid === void 0 ? void 0 : headroomSocketPath(paths, previousState.supervisorPid));
   const orphanIdentity = orphanPid === void 0 || orphanSocket === void 0 || !ports.isRunning(orphanPid) ? void 0 : daemonIdentity(ports.daemonCommandLine(orphanPid), orphanSocket);
@@ -5103,12 +5183,12 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     ticks += 1;
     config = ports.readConfig();
     const settingsHash = hashSettings(config.settings);
-    const inputs = currentHeadroomAllowlistInputs(fs13, paths, ports.frontDoorLiveness);
-    pruneDeadFrontDoorDirectRecords(fs13, paths.frontdoorDirectRecordsDir, inputs.frontDoorRecords, inputs.frontDoorLiveness);
-    pruneMalformedFrontDoorDirectFiles(fs13, paths.frontdoorDirectRecordsDir, ports.isRunning);
+    const inputs = currentHeadroomAllowlistInputs(fs14, paths, ports.frontDoorLiveness);
+    pruneDeadFrontDoorDirectRecords(fs14, paths.frontdoorDirectRecordsDir, inputs.frontDoorRecords, inputs.frontDoorLiveness);
+    pruneMalformedFrontDoorDirectFiles(fs14, paths.frontdoorDirectRecordsDir, ports.isRunning);
     const allowlist = inputs.frontDoorOrigins;
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs13, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs14, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
     if (!ownsNow && !superseded) {
       ports.log("agent-shim headroom supervisor: another supervisor now owns the state file; serving this daemon's own sessions until they end");
@@ -5155,7 +5235,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         runningSettingsHash = settingsHash;
         const recorded = writeOwnState(servingState(pid));
         if (recorded) {
-          fs13.removeRecursive(paths.headroomLockFile);
+          fs14.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
@@ -5183,7 +5263,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} now serves allowlist [${allowlist.join(", ")}]`);
       }
       if (runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs13, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        if (sessionsForSupervisor(fs14, paths.headroomSessionsDir, ports.ownPid).length === 0) {
           ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
@@ -5192,7 +5272,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs13, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs14, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -5217,9 +5297,9 @@ function undeterminedFrontDoors(inputs) {
     return reason === void 0 ? [] : [{ pid: record.pid, origin: directOrigin(record.directPort), reason }];
   });
 }
-function currentHeadroomAllowlistInputs(fs13, paths, frontDoorLiveness) {
-  const named = frontDoorOrigin(readFrontDoorState(fs13, paths.frontdoorStateFile));
-  const records = listFrontDoorDirectRecords(fs13, paths.frontdoorDirectRecordsDir);
+function currentHeadroomAllowlistInputs(fs14, paths, frontDoorLiveness) {
+  const named = frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile));
+  const records = listFrontDoorDirectRecords(fs14, paths.frontdoorDirectRecordsDir);
   const liveness = frontDoorLiveness(records.map((record) => record.pid));
   const live = liveFrontDoorDirectRecords(records, liveness).map((record) => directOrigin(record.directPort));
   return {
@@ -5228,8 +5308,8 @@ function currentHeadroomAllowlistInputs(fs13, paths, frontDoorLiveness) {
     frontDoorOrigins: [.../* @__PURE__ */ new Set([...named === void 0 ? [] : [named], ...live])].sort()
   };
 }
-function launchRequiredUpstreams(fs13, paths) {
-  const door = frontDoorOrigin(readFrontDoorState(fs13, paths.frontdoorStateFile));
+function launchRequiredUpstreams(fs14, paths) {
+  const door = frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile));
   return door === void 0 ? [] : [door];
 }
 async function waitUntilReady(ports, socketPath, pid) {
@@ -5954,8 +6034,8 @@ var init_cascade = __esm({
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
-function readActiveIdentity(fs13, activeIdentityFile) {
-  const trimmed = fs13.readFileUtf8(activeIdentityFile)?.trim();
+function readActiveIdentity(fs14, activeIdentityFile) {
+  const trimmed = fs14.readFileUtf8(activeIdentityFile)?.trim();
   return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
 }
 function isNonEmpty(value) {
@@ -6002,8 +6082,8 @@ function decideConfigProfile(params) {
   }
   return { source: "none" };
 }
-function loadIdentity(identitiesDir, name, fs13) {
-  return loadConfigFile(import_node_path17.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs13.readConfigFile);
+function loadIdentity(identitiesDir, name, fs14) {
+  return loadConfigFile(import_node_path17.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs14.readConfigFile);
 }
 var import_node_path17, IDENTITY_DECISION_SOURCES, CONFIG_PROFILE_DECISION_SOURCES;
 var init_identity = __esm({
@@ -6245,14 +6325,14 @@ function isIdentityName(name) {
 function claudeJsonPath(identitiesDir, identity) {
   return import_node_path18.default.join(identitiesDir, identity, CLAUDE_JSON);
 }
-function readAccountMetadata(fs13, identitiesDir, identity) {
+function readAccountMetadata(fs14, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return readAccountMetadataFile(fs13, claudeJsonPath(identitiesDir, identity));
+  return readAccountMetadataFile(fs14, claudeJsonPath(identitiesDir, identity));
 }
-function readAccountMetadataFile(fs13, file) {
-  const raw = fs13.readFileUtf8(file);
+function readAccountMetadataFile(fs14, file) {
+  const raw = fs14.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -6282,19 +6362,19 @@ function readAccountMetadataFile(fs13, file) {
   }
   return account.data;
 }
-function createAccountReader(fs13, identitiesDir) {
+function createAccountReader(fs14, identitiesDir) {
   const cache = /* @__PURE__ */ new Map();
   return (identity) => {
     if (!isIdentityName(identity)) {
       throw new Error(`"${identity}" is not a valid identity name.`);
     }
-    const stat = fs13.lstat(claudeJsonPath(identitiesDir, identity));
+    const stat = fs14.lstat(claudeJsonPath(identitiesDir, identity));
     const stamp = stat === void 0 ? "absent" : `${String(stat.mtimeMs)}:${String(stat.sizeBytes)}`;
     const cached = cache.get(identity);
     if (cached?.stamp === stamp) {
       return cached.account;
     }
-    const account = readAccountMetadata(fs13, identitiesDir, identity);
+    const account = readAccountMetadata(fs14, identitiesDir, identity);
     cache.set(identity, { stamp, account });
     return account;
   };
@@ -6878,8 +6958,8 @@ function segmentDay(epochMs) {
 function segmentName(day, pid) {
   return `${day}.${String(pid)}.jsonl`;
 }
-function listLogSegments(fs13, logDir) {
-  return fs13.readdir(logDir).flatMap((name) => {
+function listLogSegments(fs14, logDir) {
+  return fs14.readdir(logDir).flatMap((name) => {
     const match = SEGMENT_RE.exec(name);
     const day = match?.[1];
     if (day === void 0) {
@@ -6888,15 +6968,15 @@ function listLogSegments(fs13, logDir) {
     return [{ name, day, endsAt: Date.parse(`${day}T00:00:00.000Z`) + DAY_MS }];
   }).sort((left, right) => left.day.localeCompare(right.day) || left.name.localeCompare(right.name));
 }
-function readUsageLog(fs13, logDir, options = {}) {
+function readUsageLog(fs14, logDir, options = {}) {
   const { sinceMs } = options;
   const records = [];
   let invalidLines = 0;
-  for (const segment of listLogSegments(fs13, logDir)) {
+  for (const segment of listLogSegments(fs14, logDir)) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs13.readFileUtf8(import_node_path19.default.join(logDir, segment.name));
+    const contents = fs14.readFileUtf8(import_node_path19.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -6932,9 +7012,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return import_node_path19.default.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs13, snapshotsDir, identity) {
+function readUsageSnapshot(fs14, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs13.readFileUtf8(file);
+  const raw = fs14.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -6950,8 +7030,8 @@ function readUsageSnapshot(fs13, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs13, snapshotsDir) {
-  return fs13.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs14, snapshotsDir) {
+  return fs14.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -6959,7 +7039,7 @@ function listUsageSnapshots(fs13, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs13, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs14, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -6984,11 +7064,11 @@ var init_read = __esm({
 });
 
 // src/usage/store.ts
-function pruneUsageLog(fs13, logDir, nowMs) {
+function pruneUsageLog(fs14, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
-  for (const segment of listLogSegments(fs13, logDir)) {
+  for (const segment of listLogSegments(fs14, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs13.removeRecursive(import_node_path20.default.join(logDir, segment.name));
+      fs14.removeRecursive(import_node_path20.default.join(logDir, segment.name));
     }
   }
 }
@@ -7017,7 +7097,7 @@ function foldProviderState(current, record) {
   };
 }
 function createUsageStore(deps) {
-  const { fs: fs13, paths } = deps;
+  const { fs: fs14, paths } = deps;
   let prunedDay;
   const rewriteSnapshot = (identity, fold) => {
     if (!isIdentityName(identity)) {
@@ -7026,7 +7106,7 @@ function createUsageStore(deps) {
     }
     let current;
     try {
-      current = readUsageSnapshot(fs13, paths.usageSnapshotsDir, identity);
+      current = readUsageSnapshot(fs14, paths.usageSnapshotsDir, identity);
     } catch (error) {
       if (!(error instanceof UsageSnapshotError)) {
         throw error;
@@ -7053,8 +7133,8 @@ function createUsageStore(deps) {
       ...account === void 0 ? {} : { account },
       providers
     });
-    fs13.mkdirPrivate(paths.usageSnapshotsDir);
-    fs13.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
+    fs14.mkdirPrivate(paths.usageSnapshotsDir);
+    fs14.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
 `);
     deps.publish?.(snapshot);
     return true;
@@ -7063,14 +7143,14 @@ function createUsageStore(deps) {
     record: (input) => {
       const record = UsageRecordSchema.parse(input);
       const nowMs = deps.now();
-      fs13.mkdirPrivate(paths.usageDir);
-      fs13.mkdirPrivate(paths.usageLogDir);
+      fs14.mkdirPrivate(paths.usageDir);
+      fs14.mkdirPrivate(paths.usageLogDir);
       const day = segmentDay(nowMs);
       if (prunedDay !== day) {
-        pruneUsageLog(fs13, paths.usageLogDir, nowMs);
+        pruneUsageLog(fs14, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs13.appendFilePrivate(import_node_path20.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
+      fs14.appendFilePrivate(import_node_path20.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
 `);
       deps.onRecord?.(record);
       if (record.identity !== void 0) {
@@ -7113,14 +7193,14 @@ var init_store2 = __esm({
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function loadPoolMembers(fs13, paths, identities, nowMs) {
+function loadPoolMembers(fs14, paths, identities, nowMs) {
   const windowStartMs = nowMs - FIVE_HOUR_WINDOW_MS;
-  const log = readUsageLog(fs13, paths.usageLogDir, { sinceMs: windowStartMs });
+  const log = readUsageLog(fs14, paths.usageLogDir, { sinceMs: windowStartMs });
   return identities.map((identity) => {
     const records = log.records.filter((record) => record.identity === identity && record.provider === ANTHROPIC_PROVIDER && Date.parse(record.at) >= windowStartMs);
     try {
-      const snapshot = readUsageSnapshot(fs13, paths.usageSnapshotsDir, identity);
-      const account = readAccountMetadata(fs13, paths.identitiesDir, identity) ?? snapshot?.account;
+      const snapshot = readUsageSnapshot(fs14, paths.usageSnapshotsDir, identity);
+      const account = readAccountMetadata(fs14, paths.identitiesDir, identity) ?? snapshot?.account;
       return { identity, records, ...snapshot === void 0 ? {} : { snapshot }, ...account === void 0 ? {} : { account } };
     } catch (error) {
       if (error instanceof UsageSnapshotError || error instanceof AccountMetadataError) {
@@ -7214,9 +7294,9 @@ function collectPoolIdentities(pools, poolName, stack, found) {
     collectPoolIdentities(pools, nestedName, childStack, found);
   }
 }
-function readPicksFile(fs13, file) {
+function readPicksFile(fs14, file) {
   const empty = { schemaVersion: SCHEMA_VERSION, picks: {} };
-  const raw = fs13.readFileUtf8(file);
+  const raw = fs14.readFileUtf8(file);
   if (raw === void 0) {
     return { file: empty };
   }
@@ -7229,17 +7309,17 @@ function readPicksFile(fs13, file) {
   const result = PicksFileSchema.safeParse(parsed);
   return result.success ? { file: result.data } : { file: empty, problem: `${file} is not a picks file this agent-shim can read` };
 }
-function readStickyPick(fs13, picksFile, directory) {
-  const read = readPicksFile(fs13, picksFile);
+function readStickyPick(fs14, picksFile, directory) {
+  const read = readPicksFile(fs14, picksFile);
   const entry = read.file.picks[directory];
   return { ...entry === void 0 ? {} : { sticky: entry }, ...read.problem === void 0 ? {} : { problem: read.problem } };
 }
-function recordStickyPick(fs13, picksFile, directory, identity, nowMs) {
-  const current = readPicksFile(fs13, picksFile).file.picks;
+function recordStickyPick(fs14, picksFile, directory, identity, nowMs) {
+  const current = readPicksFile(fs14, picksFile).file.picks;
   const kept = Object.entries(current).filter(([, entry]) => nowMs - Date.parse(entry.at) <= USAGE_RETENTION_MS);
   const next = { schemaVersion: SCHEMA_VERSION, picks: { ...Object.fromEntries(kept), [directory]: { identity, at: new Date(nowMs).toISOString() } } };
-  fs13.mkdirPrivate(import_node_path21.default.dirname(picksFile));
-  fs13.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
+  fs14.mkdirPrivate(import_node_path21.default.dirname(picksFile));
+  fs14.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
 var import_node_path21, import_zod13, PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
@@ -7514,6 +7594,7 @@ function buildLayoutPaths(root) {
     frontdoorControlTokenFile: import_node_path23.default.join(root, "frontdoor", "control-token"),
     frontdoorSessionsDir: import_node_path23.default.join(root, "frontdoor", "sessions"),
     frontdoorDirectRecordsDir: import_node_path23.default.join(root, "frontdoor", "direct"),
+    frontdoorDrainingDir: import_node_path23.default.join(root, "frontdoor", "draining"),
     frontdoorRcCredentialsDir: import_node_path23.default.join(root, "frontdoor", "rc-credentials"),
     frontdoorLogPath: import_node_path23.default.join(root, "logs", "frontdoor.log"),
     usageDir: import_node_path23.default.join(root, "usage"),
@@ -8590,12 +8671,12 @@ function decideSignIn(facts) {
 function credentialsFilePath(farmRoot) {
   return import_node_path26.default.join(farmRoot, CREDENTIALS_FILE);
 }
-function identitySignIn(fs13, probe, identity) {
+function identitySignIn(fs14, probe, identity) {
   const probing = !identity.hasCredentialBlock;
   return decideSignIn({
     hasCredentialBlock: identity.hasCredentialBlock,
     keychainItem: probing && probe.platform === "darwin" && probe.run !== void 0 ? keychainHasItem(probe.run, identity.farmRoot) : void 0,
-    credentialsFile: probing && fs13.lstat(credentialsFilePath(identity.farmRoot)) !== void 0,
+    credentialsFile: probing && fs14.lstat(credentialsFilePath(identity.farmRoot)) !== void 0,
     platform: probe.platform
   });
 }
@@ -9438,6 +9519,16 @@ var init_update = __esm({
   }
 });
 
+// src/frontdoor/replacement.ts
+function replacementLine(facts) {
+  return `launcher ${String(facts.launcherPid)}: replacing front door; reason=${facts.reason} signal=${facts.signal} door=${String(facts.doorPid)} doorProtocol=${String(facts.doorProtocol)} launcherProtocol=${String(facts.launcherProtocol)} liveSessions=${String(facts.liveSessions)}`;
+}
+var init_replacement = __esm({
+  "src/frontdoor/replacement.ts"() {
+    "use strict";
+  }
+});
+
 // src/frontdoor/ensure.ts
 function ensureFrontDoor(params) {
   const { paths, ports } = params;
@@ -9448,7 +9539,7 @@ function ensureFrontDoor(params) {
   let lastRejection;
   let busyDoor;
   const liveSessionsOn = (doorPid) => listFrontDoorSessions(ports.fs, paths.frontdoorSessionsDir).filter(
-    (session) => session.pid !== params.launcherPid && ports.isRunning(session.pid) && (session.supervisorPid === void 0 || session.supervisorPid === doorPid)
+    (session) => session.pid !== params.launcherPid && ports.isRunning(session.pid) && (session.supervisorPid === void 0 || session.supervisorPid === doorPid || !ports.isRunning(session.supervisorPid))
   ).length;
   const verifyWithRetry = (port) => {
     let verdict = ports.verifyListener(port);
@@ -9458,12 +9549,20 @@ function ensureFrontDoor(params) {
     }
     return verdict;
   };
-  const stopAndAwaitExit = (supervisorPid, failure) => {
+  const recordReplacement = (doorPid, doorProtocol, reason, signal) => {
+    ports.recordReplacement(
+      replacementLine({ reason, signal, launcherPid: params.launcherPid, launcherProtocol: FRONT_DOOR_PROTOCOL, doorPid, doorProtocol, liveSessions: liveSessionsOn(doorPid) })
+    );
+  };
+  const stopAndAwaitExit = (supervisorPid, doorProtocol, reason, failure) => {
+    recordReplacement(supervisorPid, doorProtocol, reason, "SIGTERM");
     ports.stopSupervisor(supervisorPid);
     const graceEnds = ports.now() + FRONTDOOR_EXIT_GRACE_MS;
     let killed = false;
-    while (ports.isRunning(supervisorPid)) {
+    const holdsAddresses = () => ports.isRunning(supervisorPid) && readFrontDoorState(ports.fs, paths.frontdoorStateFile)?.supervisorPid === supervisorPid;
+    while (holdsAddresses()) {
       if (!killed && ports.now() >= graceEnds) {
+        recordReplacement(supervisorPid, doorProtocol, reason, "SIGKILL");
         ports.killSupervisor(supervisorPid);
         killed = true;
       }
@@ -9478,16 +9577,19 @@ function ensureFrontDoor(params) {
     const supervisorPid = state?.supervisorPid;
     if (supervisorPid !== void 0 && !distrusted.has(supervisorPid) && ports.isRunning(supervisorPid)) {
       if (state?.port !== void 0 && state.connectPort !== void 0) {
-        if (supervisorPid === params.launcherPid && params.replace !== true && ports.isFrontDoorSupervisor(supervisorPid)) {
+        if (supervisorPid === params.launcherPid && params.replace === void 0 && ports.isFrontDoorSupervisor(supervisorPid)) {
           const token = (0, import_node_crypto10.randomUUID)();
           writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token, supervisorPid, ...recordOf(params.session) });
           return { port: state.port, connectPort: state.connectPort, token };
         }
         const verdict = verifyWithRetry(state.port);
-        if (verdict.ok && !replaced && !spawned && (params.replace === true || (state.protocol ?? 0) < FRONT_DOOR_PROTOCOL)) {
+        const doorProtocol = state.protocol ?? 0;
+        if (verdict.ok && !replaced && !spawned && (params.replace !== void 0 || doorProtocol < FRONT_DOOR_PROTOCOL)) {
           stopAndAwaitExit(
             supervisorPid,
-            `the front door (pid ${String(supervisorPid)}, protocol ${String(state.protocol ?? 0)}; this launcher speaks protocol ${String(FRONT_DOOR_PROTOCOL)}) was asked to be replaced and did not exit`
+            doorProtocol,
+            params.replace ?? "protocol-older",
+            `the front door (pid ${String(supervisorPid)}, protocol ${String(doorProtocol)}; this launcher speaks protocol ${String(FRONT_DOOR_PROTOCOL)}) was asked to be replaced and did not exit`
           );
           replaced = true;
           continue;
@@ -9503,15 +9605,15 @@ function ensureFrontDoor(params) {
         }
         if (ports.isFrontDoorSupervisor(supervisorPid)) {
           const stranded = liveSessionsOn(supervisorPid);
-          if (params.replace === true && !replaced) {
-            stopAndAwaitExit(supervisorPid, `the front door (pid ${String(supervisorPid)}) stopped answering and did not exit when asked to`);
+          if (params.replace !== void 0 && !replaced) {
+            stopAndAwaitExit(supervisorPid, doorProtocol, "probe-failed-restart", `the front door (pid ${String(supervisorPid)}) stopped answering and did not exit when asked to`);
             replaced = true;
             continue;
           }
           if (stranded > 0) {
             busyDoor = { pid: supervisorPid, sessions: stranded };
           } else {
-            stopAndAwaitExit(supervisorPid, `the front door (pid ${String(supervisorPid)}) stopped answering and did not exit when asked to`);
+            stopAndAwaitExit(supervisorPid, doorProtocol, "probe-failed-idle", `the front door (pid ${String(supervisorPid)}) stopped answering and did not exit when asked to`);
             continue;
           }
         } else {
@@ -9553,6 +9655,7 @@ var init_ensure2 = __esm({
     import_node_crypto10 = require("node:crypto");
     init_cliError();
     init_state2();
+    init_replacement();
     init_state();
     FRONTDOOR_START_TIMEOUT_MS = 3e4;
     FRONTDOOR_LAUNCHER_POLL_MS = 100;
@@ -10080,15 +10183,15 @@ function contextTokensOfTranscript(text) {
   }
   return void 0;
 }
-function newestTranscript(fs13, projectDir) {
+function newestTranscript(fs14, projectDir) {
   let newest;
   let newestMs = -Infinity;
-  for (const name of fs13.readdir(projectDir)) {
+  for (const name of fs14.readdir(projectDir)) {
     if (!name.endsWith(".jsonl")) {
       continue;
     }
     const candidate = import_node_path38.default.join(projectDir, name);
-    const stat = fs13.lstat(candidate);
+    const stat = fs14.lstat(candidate);
     if (stat?.kind === "file" && stat.mtimeMs > newestMs) {
       newestMs = stat.mtimeMs;
       newest = candidate;
@@ -10096,14 +10199,14 @@ function newestTranscript(fs13, projectDir) {
   }
   return newest;
 }
-function resumedContextTokens(fs13, params) {
+function resumedContextTokens(fs14, params) {
   const target = resumeTargetOf(params.passthrough);
   if (target === void 0) {
     return void 0;
   }
   const projectDir = import_node_path38.default.join(params.claudeHome, "projects", projectDirNameOf(params.cwd));
-  const file = target.kind === "id" ? import_node_path38.default.join(projectDir, `${target.id}.jsonl`) : newestTranscript(fs13, projectDir);
-  const text = file === void 0 ? void 0 : fs13.readFileUtf8(file);
+  const file = target.kind === "id" ? import_node_path38.default.join(projectDir, `${target.id}.jsonl`) : newestTranscript(fs14, projectDir);
+  const text = file === void 0 ? void 0 : fs14.readFileUtf8(file);
   return text === void 0 ? void 0 : contextTokensOfTranscript(text);
 }
 var import_node_path38;
@@ -10555,7 +10658,7 @@ function resolveIdentityCredential(identity, credential, env, port) {
   return resolution.ok ? resolution : { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
 }
 function pickFromPool(decided, params, parsedArgv, readOnly) {
-  const { paths, fs: fs13, proc, log } = params;
+  const { paths, fs: fs14, proc, log } = params;
   if (decided.pool === void 0) {
     return { identityDecision: decided };
   }
@@ -10574,7 +10677,7 @@ function pickFromPool(decided, params, parsedArgv, readOnly) {
     selectedVia: decided.source,
     pools: params.pools,
     paths,
-    fs: fs13,
+    fs: fs14,
     usageFs: farmRuntime.fs,
     cwd: farmRuntime.cwd,
     now: farmRuntime.now,
@@ -10597,7 +10700,7 @@ function pickFromPool(decided, params, parsedArgv, readOnly) {
   };
 }
 function decideLaunch(params, readOnly) {
-  const { paths, fs: fs13, proc, log } = params;
+  const { paths, fs: fs14, proc, log } = params;
   const { env, argv } = proc;
   const parsedArgv = parseLauncherArgv(argv);
   const cliOverride = buildCliOverride({
@@ -10612,7 +10715,7 @@ function decideLaunch(params, readOnly) {
     argv0Identity: parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
-      const raw = fs13.readFileUtf8(paths.activeIdentityFile);
+      const raw = fs14.readFileUtf8(paths.activeIdentityFile);
       if (raw === void 0) {
         return void 0;
       }
@@ -10647,7 +10750,7 @@ function decideLaunch(params, readOnly) {
   }
   let loadedIdentity;
   if (identityDecision.name !== void 0) {
-    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs13);
+    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs14);
     if (loadedIdentity === void 0) {
       log.error(
         `agent-shim: no identity named "${identityDecision.name}" (selected via ${identityDecision.source}). Run \`agent-shim identity add ${identityDecision.name}\` first.`
@@ -10662,7 +10765,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs13.readConfigFile(import_node_path39.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs14.readConfigFile(import_node_path39.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -10671,7 +10774,7 @@ function decideLaunch(params, readOnly) {
   const farmContext = farm !== void 0 && farmIdentity !== void 0 ? { farm, identity: farmIdentity, cascade: farm.loadCascade(configProfileDecision.name, cliOverride) } : void 0;
   const providerParams = {
     paths,
-    port: fs13,
+    port: fs14,
     ...parsedArgv.provider === void 0 || parsedArgv.provider === false ? {} : { cliProvider: parsedArgv.provider },
     ...farmContext === void 0 ? {} : { cascade: farmContext.cascade }
   };
@@ -10770,9 +10873,9 @@ function decideLaunch(params, readOnly) {
   const flags = loginlessProvider === void 0 ? requestedFlags : { ...requestedFlags, remoteControl: false };
   const globalModels = loadConfigFile(paths.globalConfigFile, GlobalConfigSchema, params.fs.readConfigFile)?.config.models;
   const models = launchCascade !== void 0 && params.farm !== void 0 ? cascadeModels : globalModels;
-  const listedProviders = listProviderNames(fs13.readdir, paths.providersDir).flatMap((name) => {
+  const listedProviders = listProviderNames(fs14.readdir, paths.providersDir).flatMap((name) => {
     try {
-      const definition = loadProvider(paths.providersDir, name, fs13);
+      const definition = loadProvider(paths.providersDir, name, fs14);
       return definition === void 0 ? [] : [[name, definition, parseCatalogueCache(params.fs.readFileUtf8(catalogueCachePath(paths, name)))?.models ?? []]];
     } catch {
       return [];
@@ -11053,6 +11156,20 @@ var init_ownCli = __esm({
   }
 });
 
+// src/frontdoor/doorLog.ts
+function appendDoorLog(paths, line) {
+  import_node_fs12.default.mkdirSync(paths.logsDir, { recursive: true });
+  import_node_fs12.default.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+}
+var import_node_fs12;
+var init_doorLog = __esm({
+  "src/frontdoor/doorLog.ts"() {
+    "use strict";
+    import_node_fs12 = __toESM(require("node:fs"), 1);
+  }
+});
+
 // src/frontdoor/selfIdentity.ts
 function isFrontDoorSupervisorPid(pid, identify) {
   return declaredPid !== void 0 && pid === declaredPid && pid === process.pid || identify(pid);
@@ -11066,14 +11183,14 @@ var init_selfIdentity = __esm({
 
 // src/frontdoor/trust.ts
 function resolveTrustBundle(params) {
-  const { caCertFile, bundlesDir, variable, inherited, fs: fs13 } = params;
+  const { caCertFile, bundlesDir, variable, inherited, fs: fs14 } = params;
   if (inherited === void 0 || inherited === "" || import_node_path41.default.resolve(inherited) === import_node_path41.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
-  const caPem = fs13.readFileUtf8(caCertFile);
+  const caPem = fs14.readFileUtf8(caCertFile);
   let inheritedPem;
   try {
-    inheritedPem = fs13.readFileUtf8(inherited);
+    inheritedPem = fs14.readFileUtf8(inherited);
   } catch (error) {
     return {
       path: caCertFile,
@@ -11086,9 +11203,9 @@ function resolveTrustBundle(params) {
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
   const bundle = import_node_path41.default.join(bundlesDir, `${(0, import_node_crypto12.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
-  if (!fs13.exists(bundle)) {
-    fs13.mkdirp(bundlesDir);
-    fs13.writeFileAtomic(bundle, combined);
+  if (!fs14.exists(bundle)) {
+    fs14.mkdirp(bundlesDir);
+    fs14.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
@@ -11111,6 +11228,9 @@ function realEnsurePorts(paths, spawnDaemon) {
     sleep: realSleepSync,
     spawnSupervisor: (layout) => spawnDaemon(layout, "__frontdoor-supervisor", layout.frontdoorLogPath),
     isFrontDoorSupervisor: (pid) => isFrontDoorSupervisorPid(pid, realIsFrontDoorSupervisor),
+    recordReplacement: (line) => {
+      appendDoorLog(paths, line);
+    },
     stopSupervisor: (pid) => {
       process.kill(pid, "SIGTERM");
     },
@@ -11118,7 +11238,7 @@ function realEnsurePorts(paths, spawnDaemon) {
       process.kill(pid, "SIGKILL");
     },
     // Read fresh for each probe: a replacement supervisor may have regenerated an unparseable CA, and the probe must trust exactly what the serving door's leaf chains to.
-    verifyListener: (port) => probeFrontDoorSync(port, import_node_fs12.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
+    verifyListener: (port) => probeFrontDoorSync(port, import_node_fs13.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
   };
 }
 function realFrontDoorPort(paths, spawnDaemon) {
@@ -11139,22 +11259,23 @@ function realFrontDoorPort(paths, spawnDaemon) {
     }
   };
 }
-var import_node_fs12, realTrustBundleFs;
+var import_node_fs13, realTrustBundleFs;
 var init_realFrontDoorPort = __esm({
   "src/frontdoor/realFrontDoorPort.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("node:fs"), 1);
+    import_node_fs13 = __toESM(require("node:fs"), 1);
     init_realPorts();
+    init_doorLog();
     init_ensure2();
     init_state();
     init_probe();
     init_selfIdentity();
     init_trust();
     realTrustBundleFs = {
-      readFileUtf8: (file) => import_node_fs12.default.readFileSync(file, "utf8"),
-      exists: (file) => import_node_fs12.default.existsSync(file),
+      readFileUtf8: (file) => import_node_fs13.default.readFileSync(file, "utf8"),
+      exists: (file) => import_node_fs13.default.existsSync(file),
       mkdirp: (dir) => {
-        import_node_fs12.default.mkdirSync(dir, { recursive: true });
+        import_node_fs13.default.mkdirSync(dir, { recursive: true });
       },
       writeFileAtomic: (file, contents) => {
         realFarmFs.writeFilePrivate(file, contents);
@@ -13898,6 +14019,10 @@ function realConnectEffects(ports = DOOR_SOURCE_PORTS) {
       }
       resolve({
         port: bound,
+        // The listening socket is released by `close` at once; the connections already accepted are untouched and keep the server's `close` callback pending until they end.
+        stopAccepting: () => {
+          server.close();
+        },
         close: async () => {
           await new Promise((closeResolve) => {
             server.close(() => {
@@ -14103,11 +14228,11 @@ function credentialOfJson(parsed) {
 function sequenceNumOfJson(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
 }
-function createRcCredentialStore(fs13, dir) {
-  fs13.mkdirPrivate(dir);
+function createRcCredentialStore(fs14, dir) {
+  fs14.mkdirPrivate(dir);
   const fileFor = (sessionId) => import_node_path10.default.join(dir, `${sessionId}.json`);
   const readParsed = (sessionId) => {
-    const raw = fs13.readFileUtf8(fileFor(sessionId));
+    const raw = fs14.readFileUtf8(fileFor(sessionId));
     if (raw === void 0) {
       return void 0;
     }
@@ -14132,7 +14257,7 @@ function createRcCredentialStore(fs13, dir) {
       }
       const cursor = sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
       const record = { ...credential, ...cursor === void 0 ? {} : { highestSequenceNum: cursor } };
-      fs13.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
+      fs14.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
 `);
     },
     readCursor: (sessionId) => {
@@ -14147,14 +14272,14 @@ function createRcCredentialStore(fs13, dir) {
       }
       const credential = credentialOfJson(readParsed(sessionId));
       const record = credential === void 0 ? { highestSequenceNum } : { ...credential, highestSequenceNum };
-      fs13.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
+      fs14.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
 `);
     },
     remove: (sessionId) => {
       if (!isSafeSessionId(sessionId)) {
         return;
       }
-      fs13.removeRecursive(fileFor(sessionId));
+      fs14.removeRecursive(fileFor(sessionId));
     }
   };
 }
@@ -16057,14 +16182,18 @@ init_supervisor2();
 init_state();
 
 // src/doctorFrontDoor.ts
-function pushFrontDoor(push, supervisors, registeredPid, liveSessions) {
+function pushFrontDoor(push, supervisors, registeredPid, liveSessions, draining) {
   if (!supervisors.ok) {
     push("frontdoor", "warn", `Could not list processes to look for duplicate front door supervisors: ${supervisors.message}.`);
     return;
   }
-  const { pids } = supervisors;
+  const drainingPids = supervisors.pids.filter((pid) => draining.includes(pid));
+  for (const pid of drainingPids) {
+    push("frontdoor", "warn", `Front door supervisor pid ${String(pid)} is draining: it has released its addresses and exits once the connections it carried have ended.`, String(pid));
+  }
+  const pids = supervisors.pids.filter((pid) => !draining.includes(pid));
   if (pids.length === 0) {
-    push("frontdoor", "pass", "No front door supervisor is running.");
+    push("frontdoor", "pass", drainingPids.length === 0 ? "No front door supervisor is running." : "No front door supervisor is serving.");
     return;
   }
   const [only, ...rest] = pids;
@@ -16614,7 +16743,7 @@ function runDoctor(params) {
   }
   if (params.frontDoor !== void 0) {
     const validated3 = params.frontDoor.state.raw === void 0 ? void 0 : validateJson(FrontDoorStateSchema, params.frontDoor.state);
-    pushFrontDoor(push, params.frontDoor.supervisors, validated3?.ok === true ? validated3.data.supervisorPid : void 0, params.frontDoor.liveSessions);
+    pushFrontDoor(push, params.frontDoor.supervisors, validated3?.ok === true ? validated3.data.supervisorPid : void 0, params.frontDoor.liveSessions, params.frontDoor.draining ?? []);
     if (params.frontDoor.listeners !== void 0) {
       pushFrontDoorListeners(push, params.frontDoor.listeners);
     }
@@ -16813,7 +16942,7 @@ function collectDoctorReport(params) {
         logPath: paths.headroomLogPath
       }
     },
-    ...uid === void 0 ? {} : { frontDoor: { state: { path: paths.frontdoorStateFile, raw: realFsPort.readFileUtf8(paths.frontdoorStateFile) }, supervisors: listFrontDoorSupervisors(realRunPort, uid), liveSessions: listFrontDoorSessions(realFarmFs, paths.frontdoorSessionsDir).filter((session) => realIsProcessRunning(session.pid)), listeners: servingDoorListeners(paths) } }
+    ...uid === void 0 ? {} : { frontDoor: { state: { path: paths.frontdoorStateFile, raw: realFsPort.readFileUtf8(paths.frontdoorStateFile) }, supervisors: listFrontDoorSupervisors(realRunPort, uid), liveSessions: listFrontDoorSessions(realFarmFs, paths.frontdoorSessionsDir).filter((session) => realIsProcessRunning(session.pid)), draining: listDrainingFrontDoors(realFarmFs, paths.frontdoorDrainingDir, realIsProcessRunning), listeners: servingDoorListeners(paths) } }
   });
   return report;
 }
@@ -16859,6 +16988,8 @@ var HeadroomSocketTargetSchema = import_zod26.z.union([import_zod26.z.strictObje
 var FrontDoorStatusOutputSchema = import_zod26.z.strictObject({
   state: FrontDoorStateSchema,
   supervisorAlive: import_zod26.z.boolean(),
+  /** The pids of earlier doors that released their addresses and are finishing the connections they carried: running, but not serving anything new. */
+  draining: import_zod26.z.readonly(import_zod26.z.array(import_zod26.z.number().int().positive())),
   sessions: import_zod26.z.readonly(import_zod26.z.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
   logPath: import_zod26.z.string(),
@@ -17903,6 +18034,7 @@ function collectFrontDoorStatus(fsPort, socketTrust, paths, isRunning) {
   return {
     state,
     supervisorAlive: state.supervisorPid !== void 0 && isRunning(state.supervisorPid),
+    draining: listDrainingFrontDoors(fsPort, paths.frontdoorDrainingDir, isRunning),
     sessions: listFrontDoorSessions(fsPort, paths.frontdoorSessionsDir).map((session) => ({ ...session, alive: isRunning(session.pid) })),
     headroomSocket: headroomSocketTarget(fsPort, socketTrust, paths),
     logPath: paths.frontdoorLogPath,
@@ -17926,6 +18058,9 @@ function formatFrontDoorStatus(status, caCertPath) {
   } else {
     lines.push(`connect surface: listening on 127.0.0.1:${String(status.state.connectPort)}, CA ${caCertPath}`);
   }
+  if (status.draining.length > 0) {
+    lines.push(`draining: ${status.draining.map(String).join(", ")} (finishing connections opened before the last restart; each exits when they have ended)`);
+  }
   if (status.headroomSocket === void 0) {
     lines.push("headroom hop: the daemon is not serving (sessions asking for headroom fail until it is up)");
   } else if (status.headroomSocket.refused === void 0) {
@@ -18340,6 +18475,7 @@ function createRcEventFanout() {
 }
 function createRcStreamHub(deps) {
   const attachments = /* @__PURE__ */ new Map();
+  let closed = false;
   const lastSavedSequenceNums = /* @__PURE__ */ new Map();
   const persistCursor = (sessionId) => {
     if (deps.saveSequenceNum === void 0) {
@@ -18498,6 +18634,9 @@ function createRcStreamHub(deps) {
   };
   return {
     reconcile: () => {
+      if (closed) {
+        return;
+      }
       const live = new Set(deps.trackedSessions());
       for (const [sessionId, attachment] of attachments) {
         if (!live.has(sessionId)) {
@@ -18520,6 +18659,7 @@ function createRcStreamHub(deps) {
       }
     },
     close: () => {
+      closed = true;
       for (const attachment of attachments.values()) {
         persistCursor(attachment.sessionId);
         const credential = deps.credentialOf(attachment.sessionId);
@@ -19824,8 +19964,8 @@ var SELF_HOST_SUBSCRIPTION_TYPE = "max";
 function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readJsonObject(fs13, file) {
-  const raw = fs13.readFileUtf8(file);
+function readJsonObject(fs14, file) {
+  const raw = fs14.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -19837,8 +19977,8 @@ function readJsonObject(fs13, file) {
   }
   return isRecord14(parsed) ? parsed : void 0;
 }
-function readRcSelfHostRecord(fs13, frontdoorDir) {
-  const parsed = readJsonObject(fs13, import_node_path34.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+function readRcSelfHostRecord(fs14, frontdoorDir) {
+  const parsed = readJsonObject(fs14, import_node_path34.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
   if (parsed === void 0) {
     return void 0;
   }
@@ -19939,17 +20079,17 @@ function parseEntry2(project, entry) {
   const base = match?.[1];
   return base === void 0 ? { project, sessionId: entry, superseded: false, entry } : { project, sessionId: base, superseded: true, entry };
 }
-function listSessions2(fs13, configDir) {
+function listSessions2(fs14, configDir) {
   const found = [];
-  for (const project of fs13.readdir(import_node_path35.default.join(configDir, PROJECTS_DIR))) {
+  for (const project of fs14.readdir(import_node_path35.default.join(configDir, PROJECTS_DIR))) {
     const projectDir = import_node_path35.default.join(configDir, PROJECTS_DIR, project);
     const entries = /* @__PURE__ */ new Set();
-    for (const name of fs13.readdir(projectDir)) {
+    for (const name of fs14.readdir(projectDir)) {
       if (name.endsWith(TRANSCRIPT_SUFFIX)) {
         entries.add(name.slice(0, -TRANSCRIPT_SUFFIX.length));
         continue;
       }
-      const children = fs13.readdir(import_node_path35.default.join(projectDir, name));
+      const children = fs14.readdir(import_node_path35.default.join(projectDir, name));
       if (children.includes(SUBAGENTS_DIR) || children.includes(WORKFLOWS_DIR)) {
         entries.add(name);
       }
@@ -19960,9 +20100,9 @@ function listSessions2(fs13, configDir) {
   }
   return found.sort((left, right) => left.project.localeCompare(right.project) || left.entry.localeCompare(right.entry));
 }
-function locateAgents(fs13, configDir, relativeDir, workflowRunId, report) {
+function locateAgents(fs14, configDir, relativeDir, workflowRunId, report) {
   const located = [];
-  for (const name of listDirOrReport(fs13, configDir, relativeDir, report)) {
+  for (const name of listDirOrReport(fs14, configDir, relativeDir, report)) {
     if (!name.startsWith(AGENT_FILE_PREFIX) || !name.endsWith(META_SUFFIX)) {
       continue;
     }
@@ -20011,17 +20151,17 @@ function toNode(read, children) {
 function describeFailure(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function readFileOrReport(fs13, configDir, relative, report) {
+function readFileOrReport(fs14, configDir, relative, report) {
   try {
-    return fs13.readFileUtf8(import_node_path35.default.join(configDir, relative));
+    return fs14.readFileUtf8(import_node_path35.default.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be read: ${describeFailure(error)}` });
     return void 0;
   }
 }
-function listDirOrReport(fs13, configDir, relative, report) {
+function listDirOrReport(fs14, configDir, relative, report) {
   try {
-    return fs13.readdir(import_node_path35.default.join(configDir, relative));
+    return fs14.readdir(import_node_path35.default.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be listed: ${describeFailure(error)}` });
     return [];
@@ -20044,22 +20184,22 @@ var WorkflowRunFileSchema = import_zod31.z.object({
   phases: import_zod31.z.array(import_zod31.z.object({ title: import_zod31.z.string() })).default([]),
   summary: import_zod31.z.string().optional()
 });
-function summariseSession(fs13, configDir, ref) {
+function summariseSession(fs14, configDir, ref) {
   const sessionRelative = import_node_path35.default.join(PROJECTS_DIR, ref.project, ref.entry);
   const subagentsRelative = import_node_path35.default.join(sessionRelative, SUBAGENTS_DIR);
   const workflowsUnderSubagents = import_node_path35.default.join(subagentsRelative, WORKFLOWS_DIR);
   const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
-  let agentCount = fs13.readdir(import_node_path35.default.join(configDir, subagentsRelative)).filter(isMeta).length;
-  for (const runDir of fs13.readdir(import_node_path35.default.join(configDir, workflowsUnderSubagents))) {
+  let agentCount = fs14.readdir(import_node_path35.default.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs14.readdir(import_node_path35.default.join(configDir, workflowsUnderSubagents))) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      agentCount += fs13.readdir(import_node_path35.default.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+      agentCount += fs14.readdir(import_node_path35.default.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
     }
   }
-  const workflowRunCount = fs13.readdir(import_node_path35.default.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
-  const transcript = fs13.lstat(import_node_path35.default.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
+  const workflowRunCount = fs14.readdir(import_node_path35.default.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs14.lstat(import_node_path35.default.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
   return { ...ref, agentCount, workflowRunCount, ...transcript === void 0 ? {} : { updatedAt: new Date(transcript.mtimeMs).toISOString() } };
 }
-function readSessionAgentTree(fs13, configDir, ref, options = {}) {
+function readSessionAgentTree(fs14, configDir, ref, options = {}) {
   const problems = [];
   const report = (problem) => {
     problems.push(problem);
@@ -20067,15 +20207,15 @@ function readSessionAgentTree(fs13, configDir, ref, options = {}) {
   const sessionRelative = import_node_path35.default.join(PROJECTS_DIR, ref.project, ref.entry);
   const subagentsRelative = import_node_path35.default.join(sessionRelative, SUBAGENTS_DIR);
   const workflowsUnderSubagents = import_node_path35.default.join(subagentsRelative, WORKFLOWS_DIR);
-  const located = locateAgents(fs13, configDir, subagentsRelative, void 0, report);
-  for (const runDir of listDirOrReport(fs13, configDir, workflowsUnderSubagents, report)) {
+  const located = locateAgents(fs14, configDir, subagentsRelative, void 0, report);
+  for (const runDir of listDirOrReport(fs14, configDir, workflowsUnderSubagents, report)) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      located.push(...locateAgents(fs13, configDir, import_node_path35.default.join(workflowsUnderSubagents, runDir), runDir, report));
+      located.push(...locateAgents(fs14, configDir, import_node_path35.default.join(workflowsUnderSubagents, runDir), runDir, report));
     }
   }
   const agents = /* @__PURE__ */ new Map();
   for (const candidate of located) {
-    const text = readFileOrReport(fs13, configDir, candidate.metaPath, report);
+    const text = readFileOrReport(fs14, configDir, candidate.metaPath, report);
     if (text === void 0) {
       continue;
     }
@@ -20087,7 +20227,7 @@ function readSessionAgentTree(fs13, configDir, ref, options = {}) {
     agents.set(candidate.id, { located: candidate, meta: parsed.data });
   }
   const teamNames = [...new Set([...agents.values()].flatMap((agent) => agent.meta.teamName === void 0 ? [] : [agent.meta.teamName]))].sort();
-  const parentOf3 = resolveParents(fs13, configDir, agents, report);
+  const parentOf3 = resolveParents(fs14, configDir, agents, report);
   const childrenOf = /* @__PURE__ */ new Map();
   const roots = [];
   for (const id of agents.keys()) {
@@ -20110,12 +20250,12 @@ function readSessionAgentTree(fs13, configDir, ref, options = {}) {
     sessionId: ref.sessionId,
     superseded: ref.superseded,
     agents: roots.sort().map(build),
-    tasks: readTasks(fs13, configDir, ownTaskLists(ref.sessionId), [.../* @__PURE__ */ new Set([...teamNames, ...options.taskListIds ?? []])].filter((id) => !ownTaskLists(ref.sessionId).includes(id)), report),
-    workflowRuns: readWorkflowRuns(fs13, configDir, import_node_path35.default.join(sessionRelative, WORKFLOWS_DIR), report),
+    tasks: readTasks(fs14, configDir, ownTaskLists(ref.sessionId), [.../* @__PURE__ */ new Set([...teamNames, ...options.taskListIds ?? []])].filter((id) => !ownTaskLists(ref.sessionId).includes(id)), report),
+    workflowRuns: readWorkflowRuns(fs14, configDir, import_node_path35.default.join(sessionRelative, WORKFLOWS_DIR), report),
     problems
   };
 }
-function resolveParents(fs13, configDir, agents, report) {
+function resolveParents(fs14, configDir, agents, report) {
   const parentOf3 = /* @__PURE__ */ new Map();
   const transcriptCache = /* @__PURE__ */ new Map();
   const transcriptOf = (agent) => {
@@ -20123,7 +20263,7 @@ function resolveParents(fs13, configDir, agents, report) {
     if (cached !== void 0) {
       return cached;
     }
-    const text = readFileOrReport(fs13, configDir, agent.located.transcriptPath, report) ?? "";
+    const text = readFileOrReport(fs14, configDir, agent.located.transcriptPath, report) ?? "";
     transcriptCache.set(agent.located.id, text);
     return text;
   };
@@ -20173,16 +20313,16 @@ function resolveParents(fs13, configDir, agents, report) {
 function ownTaskLists(sessionId) {
   return [sessionId, `${SHORT_SESSION_LIST_PREFIX}${sessionId.slice(0, SHORT_SESSION_ID_LENGTH)}`];
 }
-function readTasks(fs13, configDir, ownLists, sharedLists, report) {
+function readTasks(fs14, configDir, ownLists, sharedLists, report) {
   const tasks = [];
   [...ownLists, ...sharedLists].forEach((scope, index) => {
     const relativeDir = import_node_path35.default.join(TASKS_DIR, scope);
-    for (const name of [...listDirOrReport(fs13, configDir, relativeDir, report)].sort()) {
+    for (const name of [...listDirOrReport(fs14, configDir, relativeDir, report)].sort()) {
       if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
         continue;
       }
       const relative = import_node_path35.default.join(relativeDir, name);
-      const text = readFileOrReport(fs13, configDir, relative, report);
+      const text = readFileOrReport(fs14, configDir, relative, report);
       const parsed = TaskFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
       if (parsed.success) {
         tasks.push(index < ownLists.length ? parsed.data : { ...parsed.data, taskList: scope });
@@ -20193,14 +20333,14 @@ function readTasks(fs13, configDir, ownLists, sharedLists, report) {
   });
   return tasks;
 }
-function readWorkflowRuns(fs13, configDir, relativeDir, report) {
+function readWorkflowRuns(fs14, configDir, relativeDir, report) {
   const runs = [];
-  for (const name of [...listDirOrReport(fs13, configDir, relativeDir, report)].sort()) {
+  for (const name of [...listDirOrReport(fs14, configDir, relativeDir, report)].sort()) {
     if (!name.startsWith(WORKFLOW_RUN_PREFIX) || !name.endsWith(JSON_SUFFIX)) {
       continue;
     }
     const relative = import_node_path35.default.join(relativeDir, name);
-    const text = readFileOrReport(fs13, configDir, relative, report);
+    const text = readFileOrReport(fs14, configDir, relative, report);
     const parsed = WorkflowRunFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
     if (!parsed.success) {
       if (text !== void 0) {
@@ -20226,11 +20366,11 @@ var SessionLookupError = class extends CliError {
 function identityConfigDir(identitiesDir, identity) {
   return import_node_path36.default.join(identitiesDir, identity);
 }
-function historyStores(fs13, identitiesDir, identities) {
+function historyStores(fs14, identitiesDir, identities) {
   const byRealPath = /* @__PURE__ */ new Map();
   for (const identity of identities) {
     const configDir = identityConfigDir(identitiesDir, identity);
-    const real = fs13.realpath(import_node_path36.default.join(configDir, "projects"));
+    const real = fs14.realpath(import_node_path36.default.join(configDir, "projects"));
     if (real === void 0) {
       continue;
     }
@@ -20243,15 +20383,15 @@ function historyStores(fs13, identitiesDir, identities) {
   }
   return [...byRealPath.values()];
 }
-function collectSessionList(fs13, identitiesDir, identities, filters) {
+function collectSessionList(fs14, identitiesDir, identities, filters) {
   const names = filters.identity === void 0 ? identities : identities.filter((name) => name === filters.identity);
   if (filters.identity !== void 0 && names.length === 0) {
     throw new SessionLookupError(`no identity named "${filters.identity}"`);
   }
   const sessions = [];
-  for (const store of historyStores(fs13, identitiesDir, names)) {
-    for (const ref of listSessions2(fs13, store.configDir)) {
-      const summary = summariseSession(fs13, store.configDir, ref);
+  for (const store of historyStores(fs14, identitiesDir, names)) {
+    for (const ref of listSessions2(fs14, store.configDir)) {
+      const summary = summariseSession(fs14, store.configDir, ref);
       if (filters.all === true || summary.agentCount > 0 || summary.workflowRunCount > 0) {
         sessions.push({ ...summary, identities: store.identities });
       }
@@ -20259,14 +20399,14 @@ function collectSessionList(fs13, identitiesDir, identities, filters) {
   }
   return sessions.sort((left, right) => (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "") || left.sessionId.localeCompare(right.sessionId));
 }
-function locateSession(fs13, identitiesDir, identities, query, onlyIdentity) {
+function locateSession(fs14, identitiesDir, identities, query, onlyIdentity) {
   const names = onlyIdentity === void 0 ? identities : identities.filter((name) => name === onlyIdentity);
   if (onlyIdentity !== void 0 && names.length === 0) {
     throw new SessionLookupError(`no identity named "${onlyIdentity}"`);
   }
   const matches = [];
-  for (const store of historyStores(fs13, identitiesDir, names)) {
-    for (const ref of listSessions2(fs13, store.configDir)) {
+  for (const store of historyStores(fs14, identitiesDir, names)) {
+    for (const ref of listSessions2(fs14, store.configDir)) {
       if (ref.sessionId.startsWith(query)) {
         matches.push({ identities: store.identities, configDir: store.configDir, ref });
       }
@@ -20283,9 +20423,9 @@ function locateSession(fs13, identitiesDir, identities, query, onlyIdentity) {
   }
   throw new SessionLookupError(`"${query}" matches ${String(candidates.length)} sessions: ${candidates.map((match) => `${match.ref.sessionId} (${match.identities.join(", ")})`).join("; ")}; give more of the id or pass --identity`);
 }
-function showSession(fs13, identitiesDir, identities, query, onlyIdentity) {
-  const located = locateSession(fs13, identitiesDir, identities, query, onlyIdentity);
-  return { identities: located.identities, tree: readSessionAgentTree(fs13, located.configDir, located.ref) };
+function showSession(fs14, identitiesDir, identities, query, onlyIdentity) {
+  const located = locateSession(fs14, identitiesDir, identities, query, onlyIdentity);
+  return { identities: located.identities, tree: readSessionAgentTree(fs14, located.configDir, located.ref) };
 }
 
 // src/agents/realFs.ts