agent-shim 11.82.0 → 11.83.1

package/dist/index.mjs

@@ -1278,7 +1278,7 @@ function parseIgnoringUnrecognisedKeys(schema, raw) {
   return second.success ? { success: true, data: second.data, ignored } : { success: false, issues: second.error.issues };
 }
 function describeIgnoredKeys(filePath, ignored) {
-  const places = ignored.map(({ path: path42, keys }) => `${path42.length === 0 ? "" : `${path42.map(String).join(".")}.`}${keys.join(", ")}`);
+  const places = ignored.map(({ path: path45, keys }) => `${path45.length === 0 ? "" : `${path45.map(String).join(".")}.`}${keys.join(", ")}`);
   return `${filePath} has settings this version of agent-shim does not know and ignores: ${places.join("; ")}. A newer release may read them.`;
 }
 function noteIgnoredKeys(filePath, ignored) {
@@ -1300,9 +1300,9 @@ function restoreIgnoredKeys(filePath, value) {
     return value;
   }
   const restored = structuredClone(value);
-  for (const { path: path42, values } of ignored) {
+  for (const { path: path45, values } of ignored) {
     let holder = restored;
-    for (const step of path42) {
+    for (const step of path45) {
       holder = isRecord(holder) ? holder[step] : void 0;
     }
     if (isRecord(holder)) {
@@ -1350,6 +1350,12 @@ function captureRuleEntryOrders(value) {
   }
   return rules.map((rule) => captureEntryOrder(rule));
 }
+function unparseableFile(error, filepath) {
+  if (error instanceof SyntaxError) {
+    return new ConfigFileNotJsonError(filepath);
+  }
+  return error instanceof Error && error.name === "YAMLException" ? new ConfigFileNotJsonError(filepath, "YAML") : void 0;
+}
 function cosmiconfigReader(explorer = createExplorer()) {
   return (filepath) => {
     let result;
@@ -1360,7 +1366,7 @@ function cosmiconfigReader(explorer = createExplorer()) {
       if (code === "ENOENT") {
         return void 0;
       }
-      throw error;
+      throw unparseableFile(error, filepath) ?? error;
     }
     if (result === null || result.isEmpty === true) {
       return void 0;
@@ -1385,7 +1391,7 @@ function loadConfigFile(filepath, schema, read = cosmiconfigReader()) {
     ruleEntryOrders: captureRuleEntryOrders(raw)
   };
 }
-var ConfigValidationError;
+var ConfigValidationError, ConfigFileNotJsonError;
 var init_load = __esm({
   "src/config/load.ts"() {
     "use strict";
@@ -1403,6 +1409,16 @@ ${detail}`);
       filepath;
       issues;
     };
+    ConfigFileNotJsonError = class extends CliError {
+      constructor(filepath, format = "JSON") {
+        super(`${filepath} is not valid ${format}.`);
+        this.filepath = filepath;
+        this.format = format;
+        this.name = "ConfigFileNotJsonError";
+      }
+      filepath;
+      format;
+    };
   }
 });
 
@@ -1418,7 +1434,12 @@ function readJson(filePath, schema, storeFs = nodeStoreFs) {
   if (raw === void 0) {
     return void 0;
   }
-  const parsed = JSON.parse(raw);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw error instanceof SyntaxError ? new ConfigFileNotJsonError(filePath) : error;
+  }
   const result = parseIgnoringUnrecognisedKeys(schema, parsed);
   if (!result.success) {
     throw new ConfigValidationError(filePath, result.issues);
@@ -2921,6 +2942,14 @@ function acquireIdentityLock(params) {
       return {
         path: lockPath,
         token,
+        refresh: () => {
+          const current = parseLockRecord(params.fs.readFileUtf8(lockPath));
+          if (current?.token !== token) {
+            throw new IdentityLockLostError(params.identity);
+          }
+          params.fs.writeFilePrivate(lockPath, `${JSON.stringify({ ...current, acquiredAtMs: params.nowMs() })}
+`);
+        },
         release: () => {
           const current = parseLockRecord(params.fs.readFileUtf8(lockPath));
           if (current !== void 0 && current.token !== token) {
@@ -2930,7 +2959,19 @@ function acquireIdentityLock(params) {
         }
       };
     }
-    const existing = parseLockRecord(params.fs.readFileUtf8(lockPath));
+    const raw = params.fs.readFileUtf8(lockPath);
+    if (raw === void 0) {
+      continue;
+    }
+    let existing = parseLockRecord(raw);
+    if (existing === void 0) {
+      params.sleep(retryDelayMs);
+      const again = params.fs.readFileUtf8(lockPath);
+      if (again === void 0) {
+        continue;
+      }
+      existing = parseLockRecord(again);
+    }
     if (existing === void 0) {
       params.fs.removeRecursive(lockPath);
       continue;
@@ -2945,7 +2986,7 @@ function acquireIdentityLock(params) {
   }
   throw new IdentityLockBusyError(params.identity, lockPath, lastHolderPid);
 }
-var DEFAULT_STALE_AFTER_MS, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_ATTEMPTS, IdentityLockBusyError;
+var DEFAULT_STALE_AFTER_MS, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_ATTEMPTS, IdentityLockLostError, IdentityLockBusyError;
 var init_lock = __esm({
   "src/launcher/lock.ts"() {
     "use strict";
@@ -2953,6 +2994,14 @@ var init_lock = __esm({
     DEFAULT_STALE_AFTER_MS = 12e4;
     DEFAULT_RETRY_DELAY_MS = 50;
     DEFAULT_MAX_ATTEMPTS = 200;
+    IdentityLockLostError = class extends CliError {
+      constructor(identity) {
+        super(`The lock on identity "${identity}" was taken over by another process while it was held, so nothing it guards can be assumed unchanged.`);
+        this.identity = identity;
+        this.name = "IdentityLockLostError";
+      }
+      identity;
+    };
     IdentityLockBusyError = class extends CliError {
       constructor(identity, lockPath, holderPid) {
         super(
@@ -2973,8 +3022,8 @@ var init_lock = __esm({
 // src/launcher/farm.ts
 import path8 from "node:path";
 import { z as z4 } from "zod";
-function readFarmManifest(fs14, farmRoot) {
-  const raw = fs14.readFileUtf8(path8.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs14.readFileUtf8(path8.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs15, farmRoot) {
+  const raw = fs15.readFileUtf8(path8.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs15.readFileUtf8(path8.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -3032,9 +3081,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs14, root, rel) {
+function listSubtree(fs15, root, rel) {
   const absolute = path8.join(root, rel);
-  const stat = fs14.lstat(absolute);
+  const stat = fs15.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -3042,10 +3091,10 @@ function listSubtree(fs14, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs14.readdir(absolute)].sort().flatMap((name) => listSubtree(fs14, root, `${rel}/${name}`));
+    const children = [...fs15.readdir(absolute)].sort().flatMap((name) => listSubtree(fs15, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs14.hashFile(absolute);
+  const contentHash = fs15.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -3059,25 +3108,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs14, farmRoot, manifest) {
+function reconciliationScope(fs15, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs14.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs14.lstat(path8.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs15.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs15.lstat(path8.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs14, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs14, farmRoot, root));
+function collectFarmListing(fs15, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs15, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs14, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs15, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = path8.join(claudeHome, entry.rel);
-    const stat = fs14.lstat(absolute);
+    const stat = fs15.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs14.hashFile(absolute);
+      const contentHash = fs15.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -3319,6 +3368,9 @@ function resyncFarm(params) {
       farmRoot,
       classification: params.classification
     });
+    if (params.identityExists?.() === false) {
+      throw new IdentityGoneError(params.identity);
+    }
     const previousManifest = readFarmManifest(params.fs, farmRoot);
     const scope = reconciliationScope(params.fs, farmRoot, previousManifest);
     const farmListing = collectFarmListing(params.fs, farmRoot, scope);
@@ -3434,13 +3486,14 @@ function recoveryDiagnostics(recovery, identity) {
     }
   ];
 }
-var FARM_MANIFEST_FILENAME, FarmManifestSchema;
+var FARM_MANIFEST_FILENAME, FarmManifestSchema, IdentityGoneError;
 var init_farm = __esm({
   "src/launcher/farm.ts"() {
     "use strict";
     init_classify();
     init_reconcile();
     init_pipeline();
+    init_cliError();
     init_legacy();
     init_lock();
     FARM_MANIFEST_FILENAME = ".agent-shim-farm.json";
@@ -3454,6 +3507,14 @@ var init_farm = __esm({
       materialised: z4.array(z4.string()),
       links: z4.array(z4.strictObject({ rel: z4.string(), target: z4.string() }))
     });
+    IdentityGoneError = class extends CliError {
+      constructor(identity) {
+        super(`Identity "${identity}" no longer exists: it was renamed or removed while this launch waited for it. Launch it under its current name.`);
+        this.identity = identity;
+        this.name = "IdentityGoneError";
+      }
+      identity;
+    };
   }
 });
 
@@ -3848,10 +3909,10 @@ var init_route = __esm({
 // src/frontdoor/state.ts
 import path9 from "node:path";
 import { z as z5 } from "zod";
-function readFrontDoorState(fs14, stateFile) {
+function readFrontDoorState(fs15, stateFile) {
   let raw;
   try {
-    raw = fs14.readFileUtf8(stateFile);
+    raw = fs15.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -3865,9 +3926,9 @@ function readFrontDoorState(fs14, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs14, stateFile, state) {
-  fs14.mkdirp(path9.dirname(stateFile));
-  fs14.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs15, stateFile, state) {
+  fs15.mkdirp(path9.dirname(stateFile));
+  fs15.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function directOrigin(port) {
@@ -3877,37 +3938,37 @@ function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : directOrigin(port);
 }
-function writeFrontDoorDirectRecord(fs14, recordsDir, record) {
-  fs14.mkdirp(recordsDir);
-  fs14.writeFilePrivate(path9.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
+function writeFrontDoorDirectRecord(fs15, recordsDir, record) {
+  fs15.mkdirp(recordsDir);
+  fs15.writeFilePrivate(path9.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
 `);
 }
-function removeFrontDoorDirectRecord(fs14, recordsDir, pid) {
-  fs14.removeRecursive(path9.join(recordsDir, `${String(pid)}.json`));
+function removeFrontDoorDirectRecord(fs15, recordsDir, pid) {
+  fs15.removeRecursive(path9.join(recordsDir, `${String(pid)}.json`));
 }
-function markFrontDoorDraining(fs14, markersDir, pid) {
-  fs14.mkdirp(markersDir);
-  fs14.writeFilePrivate(path9.join(markersDir, String(pid)), "\n");
+function markFrontDoorDraining(fs15, markersDir, pid) {
+  fs15.mkdirp(markersDir);
+  fs15.writeFilePrivate(path9.join(markersDir, String(pid)), "\n");
 }
-function unmarkFrontDoorDraining(fs14, markersDir, pid) {
-  fs14.removeRecursive(path9.join(markersDir, String(pid)));
+function unmarkFrontDoorDraining(fs15, markersDir, pid) {
+  fs15.removeRecursive(path9.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 listDrainingFrontDoors(fs15, markersDir, isRunning) {
+  return fs15.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(fs14, recordsDir, file) {
+function readDirectRecordEntry(fs15, recordsDir, file) {
   const pid = recordPid(file);
   if (pid === void 0) {
     return void 0;
   }
   let raw;
   try {
-    raw = fs14.readFileUtf8(path9.join(recordsDir, file));
+    raw = fs15.readFileUtf8(path9.join(recordsDir, file));
   } catch {
     return void 0;
   }
@@ -3921,37 +3982,37 @@ function readDirectRecordEntry(fs14, recordsDir, file) {
     return { malformed: true };
   }
 }
-function listFrontDoorDirectRecords(fs14, recordsDir) {
-  return fs14.readdir(recordsDir).flatMap((file) => {
-    const entry = readDirectRecordEntry(fs14, recordsDir, file);
+function listFrontDoorDirectRecords(fs15, recordsDir) {
+  return fs15.readdir(recordsDir).flatMap((file) => {
+    const entry = readDirectRecordEntry(fs15, recordsDir, file);
     return entry?.record === void 0 ? [] : [entry.record];
   }).sort((a, b) => a.pid - b.pid);
 }
-function pruneMalformedFrontDoorDirectFiles(fs14, recordsDir, isRunning) {
-  for (const file of fs14.readdir(recordsDir)) {
+function pruneMalformedFrontDoorDirectFiles(fs15, recordsDir, isRunning) {
+  for (const file of fs15.readdir(recordsDir)) {
     const writer = RECORD_TEMPORARY_FILE.exec(file)?.[1];
     const stale = writer !== void 0 && !isRunning(Number(writer));
-    if (stale || readDirectRecordEntry(fs14, recordsDir, file)?.malformed === true) {
-      fs14.removeRecursive(path9.join(recordsDir, file));
+    if (stale || readDirectRecordEntry(fs15, recordsDir, file)?.malformed === true) {
+      fs15.removeRecursive(path9.join(recordsDir, file));
     }
   }
 }
 function liveFrontDoorDirectRecords(records, liveness) {
   return records.filter((record) => liveness.doors.has(record.pid) || liveness.unknown.has(record.pid));
 }
-function pruneDeadFrontDoorDirectRecords(fs14, recordsDir, records, liveness) {
+function pruneDeadFrontDoorDirectRecords(fs15, recordsDir, records, liveness) {
   for (const record of records) {
     if (!liveness.doors.has(record.pid) && !liveness.unknown.has(record.pid)) {
-      removeFrontDoorDirectRecord(fs14, recordsDir, record.pid);
+      removeFrontDoorDirectRecord(fs15, recordsDir, record.pid);
     }
   }
 }
 function recordOf(details) {
   return details === void 0 ? {} : { sessionId: details.sessionId, ...details.models === void 0 ? {} : { models: details.models } };
 }
-function writeFrontDoorSession(fs14, sessionsDir, session) {
-  fs14.mkdirPrivate(sessionsDir);
-  fs14.writeFilePrivate(path9.join(sessionsDir, sessionRecordName(session.pid)), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs15, sessionsDir, session) {
+  fs15.mkdirPrivate(sessionsDir);
+  fs15.writeFilePrivate(path9.join(sessionsDir, sessionRecordName(session.pid)), `${JSON.stringify(session, null, 2)}
 `);
 }
 function sessionRecordName(pid) {
@@ -3963,32 +4024,32 @@ function isSessionRecordName(name) {
 function summaryOf(session) {
   return { pid: session.pid, startedAt: session.startedAt, ...session.supervisorPid === void 0 ? {} : { supervisorPid: session.supervisorPid } };
 }
-function readFrontDoorSessionRecord(fs14, sessionsDir, name) {
+function readFrontDoorSessionRecord(fs15, sessionsDir, name) {
   try {
-    const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs14.readFileUtf8(path9.join(sessionsDir, name)) ?? ""));
+    const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs15.readFileUtf8(path9.join(sessionsDir, name)) ?? ""));
     return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
   }
 }
-function listFrontDoorSessions(fs14, sessionsDir) {
+function listFrontDoorSessions(fs15, sessionsDir) {
   const sessions = [];
-  for (const name of fs14.readdir(sessionsDir)) {
-    const record = isSessionRecordName(name) ? readFrontDoorSessionRecord(fs14, sessionsDir, name) : void 0;
+  for (const name of fs15.readdir(sessionsDir)) {
+    const record = isSessionRecordName(name) ? readFrontDoorSessionRecord(fs15, sessionsDir, name) : void 0;
     if (record !== void 0) {
       sessions.push(summaryOf(record));
     }
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs14, sessionsDir, pid) {
-  fs14.removeRecursive(path9.join(sessionsDir, sessionRecordName(pid)));
+function removeFrontDoorSession(fs15, sessionsDir, pid) {
+  fs15.removeRecursive(path9.join(sessionsDir, sessionRecordName(pid)));
 }
-function pruneDeadFrontDoorSessions(fs14, sessionsDir, listed, isRunning) {
+function pruneDeadFrontDoorSessions(fs15, sessionsDir, listed, isRunning) {
   const removed = [];
   for (const session of listed) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs14, sessionsDir, session.pid);
+      removeFrontDoorSession(fs15, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -4086,9 +4147,9 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
   }
 }
 async function serveFrontDoor(idleShutdownMinutes, ports, options) {
-  const { fs: fs14, paths } = ports;
+  const { fs: fs15, paths } = ports;
   const servingBinary = ports.statOwnExecutable();
-  const previous = readFrontDoorState(fs14, paths.frontdoorStateFile);
+  const previous = readFrontDoorState(fs15, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -4102,14 +4163,14 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   const fail = (message) => {
     ports.closeRcStreamHub();
     if (predecessor === void 0) {
-      writeFrontDoorState(fs14, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-      fs14.removeRecursive(paths.frontdoorLockFile);
+      writeFrontDoorState(fs15, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+      fs15.removeRecursive(paths.frontdoorLockFile);
     }
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
   if (predecessor === void 0) {
-    writeFrontDoorState(fs14, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+    writeFrontDoorState(fs15, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   }
   const previousSticky = lastPort;
   let http3;
@@ -4150,11 +4211,11 @@ 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(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() });
+  writeFrontDoorDirectRecord(fs15, paths.frontdoorDirectRecordsDir, { pid: ports.ownPid, directPort: direct.port });
+  writeFrontDoorState(fs15, 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 });
   if (predecessor === void 0) {
-    fs14.removeRecursive(paths.frontdoorLockFile);
+    fs15.removeRecursive(paths.frontdoorLockFile);
   } else {
     predecessor.serving();
   }
@@ -4163,7 +4224,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
   let idleSince;
   let ticks = 0;
   const supersedingOwner = async () => {
-    const owner = readFrontDoorState(fs14, paths.frontdoorStateFile)?.supervisorPid;
+    const owner = readFrontDoorState(fs15, paths.frontdoorStateFile)?.supervisorPid;
     return owner !== void 0 && owner !== ports.ownPid && (await ports.runningAmong([owner])).has(owner) ? owner : void 0;
   };
   let supersededBy;
@@ -4192,13 +4253,13 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     ports.stopBackgroundWork?.();
     const drained = [direct.drain(), connect3.drain(), http3.drain()];
     if (await supersedingOwner() === void 0) {
-      writeFrontDoorState(fs14, paths.frontdoorStateFile, sticky());
+      writeFrontDoorState(fs15, paths.frontdoorStateFile, sticky());
     }
-    markFrontDoorDraining(fs14, paths.frontdoorDrainingDir, ports.ownPid);
+    markFrontDoorDraining(fs15, paths.frontdoorDrainingDir, ports.ownPid);
     ports.closeRcStreamHub();
     await Promise.all(drained);
-    unmarkFrontDoorDraining(fs14, paths.frontdoorDrainingDir, ports.ownPid);
-    removeFrontDoorDirectRecord(fs14, paths.frontdoorDirectRecordsDir, ports.ownPid);
+    unmarkFrontDoorDraining(fs15, paths.frontdoorDrainingDir, ports.ownPid);
+    removeFrontDoorDirectRecord(fs15, paths.frontdoorDirectRecordsDir, ports.ownPid);
     ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: the connections this door carried have ended; exiting`);
     return 0;
   };
@@ -4219,12 +4280,12 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     await connect3.close();
     await http3.close();
     ports.closeRcStreamHub();
-    removeFrontDoorDirectRecord(fs14, paths.frontdoorDirectRecordsDir, ports.ownPid);
+    removeFrontDoorDirectRecord(fs15, paths.frontdoorDirectRecordsDir, ports.ownPid);
   };
   const shutdown = async () => {
     await closeServing();
     if (await supersedingOwner() === void 0) {
-      writeFrontDoorState(fs14, paths.frontdoorStateFile, sticky());
+      writeFrontDoorState(fs15, paths.frontdoorStateFile, sticky());
     }
     return 0;
   };
@@ -4243,7 +4304,7 @@ async function serveFrontDoor(idleShutdownMinutes, ports, options) {
     ticks += 1;
     const listed = ports.registry.rescan();
     const running = await ports.runningAmong(listed.map((session) => session.pid));
-    const pruned = pruneDeadFrontDoorSessions(fs14, paths.frontdoorSessionsDir, listed, (pid) => running.has(pid));
+    const pruned = pruneDeadFrontDoorSessions(fs15, paths.frontdoorSessionsDir, listed, (pid) => running.has(pid));
     ports.registry.forget(pruned);
     ports.observeLaunchRegistry(listed, pruned);
     ports.checkQuotaExpiry();
@@ -4318,8 +4379,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path42) {
-  return path42?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path45) {
+  return path45?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 function forwardableHeaders(headers) {
   const connectionTokens = new Set(
@@ -4763,7 +4824,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.82.0",
+      version: "11.83.1",
       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>",
@@ -4815,7 +4876,7 @@ var init_package = __esm({
         "@anthropic-ai/claude-agent-sdk": "0.3.292",
         "@clack/prompts": "^1.8.0",
         "@modelcontextprotocol/sdk": "1.32.0",
-        "@orpc/client": "2.0.0-beta.43",
+        "@orpc/client": "2.0.0-beta.46",
         "@orpc/openapi": "2.0.0-beta.43",
         "@orpc/server": "2.0.0-beta.43",
         commander: "^15.0.0",
@@ -4989,43 +5050,43 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs14, stateFile) {
+function readHeadroomState(fs15, stateFile) {
   try {
-    return parseJson(fs14.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs15.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs14, stateFile, state) {
-  fs14.mkdirp(path12.dirname(stateFile));
-  fs14.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs15, stateFile, state) {
+  fs15.mkdirp(path12.dirname(stateFile));
+  fs15.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
-function resolveServingHeadroomState(fs14, files, isRunning) {
-  const current = readHeadroomState(fs14, files.stateFile);
+function resolveServingHeadroomState(fs15, files, isRunning) {
+  const current = readHeadroomState(fs15, files.stateFile);
   if (current !== void 0) {
     return { path: files.stateFile, state: current };
   }
-  const legacy = readHeadroomState(fs14, files.legacyStateFile);
+  const legacy = readHeadroomState(fs15, files.legacyStateFile);
   if (legacy?.supervisorPid !== void 0 && isRunning(legacy.supervisorPid)) {
     return { path: files.legacyStateFile, state: legacy };
   }
   return void 0;
 }
-function migrateHeadroomState(fs14, files, isRunning) {
-  const legacy = readHeadroomState(fs14, files.legacyStateFile);
+function migrateHeadroomState(fs15, files, isRunning) {
+  const legacy = readHeadroomState(fs15, files.legacyStateFile);
   const legacyLive = legacy?.supervisorPid !== void 0 && isRunning(legacy.supervisorPid);
-  const current = readHeadroomState(fs14, files.stateFile);
+  const current = readHeadroomState(fs15, files.stateFile);
   if (current !== void 0 || legacyLive) {
-    if (!legacyLive && fs14.readFileUtf8(files.legacyStateFile) !== void 0) {
-      fs14.removeRecursive(files.legacyStateFile);
+    if (!legacyLive && fs15.readFileUtf8(files.legacyStateFile) !== void 0) {
+      fs15.removeRecursive(files.legacyStateFile);
     }
     return;
   }
   if (legacy !== void 0) {
-    writeHeadroomState(fs14, files.stateFile, legacy);
+    writeHeadroomState(fs15, files.stateFile, legacy);
   }
-  fs14.removeRecursive(files.legacyStateFile);
+  fs15.removeRecursive(files.legacyStateFile);
 }
 function hashAllowlist(allowlist) {
   return createHash3("sha256").update(allowlist.join("\n")).digest("hex");
@@ -5058,27 +5119,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(fs14, allowlistFile, allowlist) {
-  fs14.mkdirPrivate(path12.dirname(allowlistFile));
-  fs14.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
+function writeAllowlistFile(fs15, allowlistFile, allowlist) {
+  fs15.mkdirPrivate(path12.dirname(allowlistFile));
+  fs15.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
 }
-function pruneStaleAllowlistTemporaries(fs14, allowlistFile, isRunning) {
+function pruneStaleAllowlistTemporaries(fs15, allowlistFile, isRunning) {
   const prefix = `${path12.basename(allowlistFile)}.`;
-  for (const name of fs14.readdir(path12.dirname(allowlistFile))) {
+  for (const name of fs15.readdir(path12.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))) {
-      fs14.removeRecursive(path12.join(path12.dirname(allowlistFile), name));
+      fs15.removeRecursive(path12.join(path12.dirname(allowlistFile), name));
     }
   }
 }
-function readAllProviders(fs14, providersDir) {
+function readAllProviders(fs15, providersDir) {
   const result = [];
-  for (const name of fs14.readdir(providersDir)) {
+  for (const name of fs15.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs14.readFileUtf8(path12.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs15.readFileUtf8(path12.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -5088,22 +5149,22 @@ function readAllProviders(fs14, providersDir) {
   }
   return result;
 }
-function writeSession(fs14, sessionsDir, session) {
-  fs14.mkdirp(sessionsDir);
-  fs14.writeFileUtf8(path12.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs15, sessionsDir, session) {
+  fs15.mkdirp(sessionsDir);
+  fs15.writeFileUtf8(path12.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs14, sessionsDir, pid) {
-  fs14.removeRecursive(path12.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs15, sessionsDir, pid) {
+  fs15.removeRecursive(path12.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs14, sessionsDir) {
+function listSessions(fs15, sessionsDir) {
   const sessions = [];
-  for (const name of fs14.readdir(sessionsDir)) {
+  for (const name of fs15.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs14.readFileUtf8(path12.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs15.readFileUtf8(path12.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -5113,22 +5174,22 @@ function listSessions(fs14, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs14, sessionsDir, supervisorPid) {
-  return listSessions(fs14, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs15, sessionsDir, supervisorPid) {
+  return listSessions(fs15, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs14, sessionsDir, isRunning) {
+function pruneDeadSessions(fs15, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs14, sessionsDir)) {
+  for (const session of listSessions(fs15, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs14, sessionsDir, session.pid);
+      removeSession(fs15, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs14, lockFile) {
+function readStartLock(fs15, lockFile) {
   try {
-    return parseJson(fs14.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs15.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -5218,12 +5279,12 @@ function earlierReleaseAllowlistHash(providers, doorOrigin) {
   }
   return hashAllowlist([...entries].sort());
 }
-function earlierReleaseDaemon(fs14, paths, daemon) {
+function earlierReleaseDaemon(fs15, paths, daemon) {
   if (daemonIdentity(daemon.commandLine, daemon.socketPath) !== "earlier-release") {
     return void 0;
   }
-  const providers = readAllProviders(fs14, paths.providersDir).map((entry) => entry.provider);
-  const expected = earlierReleaseAllowlistHash(providers, frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile)));
+  const providers = readAllProviders(fs15, paths.providersDir).map((entry) => entry.provider);
+  const expected = earlierReleaseAllowlistHash(providers, frontDoorOrigin(readFrontDoorState(fs15, paths.frontdoorStateFile)));
   return { admitsServingDoor: daemon.recordedHash === expected };
 }
 var EARLIER_RELEASE_ALLOWLIST, EARLIER_RELEASE_ANTHROPIC_UPSTREAM;
@@ -5248,8 +5309,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(fs14, allowlistFile, recordedHash, required) {
-  const content = fs14.readFileUtf8(allowlistFile);
+function daemonAdmits(fs15, allowlistFile, recordedHash, required) {
+  const content = fs15.readFileUtf8(allowlistFile);
   if (content === void 0 || recordedHash === void 0) {
     return false;
   }
@@ -5518,7 +5579,7 @@ function verifyAllowlistFile(allowlistFile, ports) {
   const replaceable = fileStat === void 0 || fileStat.kind === "file" || fileStat.kind === "symlink";
   return { message: refusal2, repairable: replaceable };
 }
-function prepareHeadroomSocket(fs14, ports, paths, supervisorPid) {
+function prepareHeadroomSocket(fs15, ports, paths, supervisorPid) {
   const unsupported = platformRefusal(ports.platform);
   if (unsupported !== void 0) {
     return { refused: unsupported };
@@ -5533,18 +5594,18 @@ function prepareHeadroomSocket(fs14, 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` };
   }
-  fs14.mkdirPrivate(paths.headroomSocketDir);
+  fs15.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(fs14, paths, isRunning) {
+function pruneStaleHeadroomSockets(fs15, paths, isRunning) {
   const removed = [];
-  for (const name of fs14.readdir(paths.headroomSocketDir)) {
+  for (const name of fs15.readdir(paths.headroomSocketDir)) {
     const pid = HEADROOM_SOCKET_NAME.exec(name)?.[1];
     if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
       continue;
     }
-    fs14.removeRecursive(path13.join(paths.headroomSocketDir, name));
+    fs15.removeRecursive(path13.join(paths.headroomSocketDir, name));
     removed.push(name);
   }
   return removed;
@@ -5656,37 +5717,37 @@ function compareVersions2(a, b) {
   return 0;
 }
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs14, paths } = ports;
+  const { fs: fs15, paths } = ports;
   let config = initialConfig;
-  migrateHeadroomState(fs14, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning);
-  const previousState = resolveServingHeadroomState(fs14, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning)?.state;
+  migrateHeadroomState(fs15, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning);
+  const previousState = resolveServingHeadroomState(fs15, { 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(fs14, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs15, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs14, paths.headroomStateFile, state);
+    writeHeadroomState(fs15, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message })) {
-      fs14.removeRecursive(paths.headroomLockFile);
+      fs15.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
   };
   const syncAllowlistFile = (allowlist) => {
     try {
-      if (fs14.readFileUtf8(paths.headroomAllowlistFile) !== formatAllowlistFile(allowlist)) {
-        writeAllowlistFile(fs14, paths.headroomAllowlistFile, allowlist);
+      if (fs15.readFileUtf8(paths.headroomAllowlistFile) !== formatAllowlistFile(allowlist)) {
+        writeAllowlistFile(fs15, paths.headroomAllowlistFile, allowlist);
         ports.log(`agent-shim headroom supervisor: wrote allowlist [${allowlist.join(", ")}] to ${paths.headroomAllowlistFile}`);
       }
       return void 0;
@@ -5704,9 +5765,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     }
     ports.log(`agent-shim headroom supervisor: repairing the allowlist file: ${problem.message}`);
     try {
-      fs14.mkdirPrivate(paths.headroomDir);
-      fs14.mkdirPrivate(path14.dirname(paths.headroomAllowlistFile));
-      writeAllowlistFile(fs14, paths.headroomAllowlistFile, allowlist);
+      fs15.mkdirPrivate(paths.headroomDir);
+      fs15.mkdirPrivate(path14.dirname(paths.headroomAllowlistFile));
+      writeAllowlistFile(fs15, paths.headroomAllowlistFile, allowlist);
     } catch (error) {
       return `could not write the headroom allowlist file ${paths.headroomAllowlistFile}: ${error instanceof Error ? error.message : String(error)}`;
     }
@@ -5731,20 +5792,20 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     installedSource = config.source;
     return void 0;
   };
-  const socket = prepareHeadroomSocket(fs14, ports.socketTrust, paths, ports.ownPid);
+  const socket = prepareHeadroomSocket(fs15, ports.socketTrust, paths, ports.ownPid);
   if (socket.refused !== void 0) {
     return fail(socket.refused);
   }
   const { socketPath } = socket;
-  pruneStaleHeadroomSockets(fs14, paths, ports.isRunning);
-  pruneStaleAllowlistTemporaries(fs14, paths.headroomAllowlistFile, ports.isRunning);
+  pruneStaleHeadroomSockets(fs15, paths, ports.isRunning);
+  pruneStaleAllowlistTemporaries(fs15, 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(fs14, paths, ports.frontDoorLiveness).frontDoorOrigins.join(", ")}]`);
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${currentHeadroomAllowlistInputs(fs15, 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);
@@ -5782,12 +5843,12 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     }
     config = ports.readConfig();
     const settingsHash = hashSettings(config.settings);
-    const inputs = currentHeadroomAllowlistInputs(fs14, paths, ports.frontDoorLiveness);
-    pruneDeadFrontDoorDirectRecords(fs14, paths.frontdoorDirectRecordsDir, inputs.frontDoorRecords, inputs.frontDoorLiveness);
-    pruneMalformedFrontDoorDirectFiles(fs14, paths.frontdoorDirectRecordsDir, ports.isRunning);
+    const inputs = currentHeadroomAllowlistInputs(fs15, paths, ports.frontDoorLiveness);
+    pruneDeadFrontDoorDirectRecords(fs15, paths.frontdoorDirectRecordsDir, inputs.frontDoorRecords, inputs.frontDoorLiveness);
+    pruneMalformedFrontDoorDirectFiles(fs15, paths.frontdoorDirectRecordsDir, ports.isRunning);
     const allowlist = inputs.frontDoorOrigins;
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs14, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs15, 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");
@@ -5834,7 +5895,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         runningSettingsHash = settingsHash;
         const recorded = writeOwnState(servingState(pid));
         if (recorded) {
-          fs14.removeRecursive(paths.headroomLockFile);
+          fs15.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
@@ -5862,7 +5923,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(fs14, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        if (sessionsForSupervisor(fs15, 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;
@@ -5871,7 +5932,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs14, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs15, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -5896,9 +5957,9 @@ function undeterminedFrontDoors(inputs) {
     return reason === void 0 ? [] : [{ pid: record.pid, origin: directOrigin(record.directPort), reason }];
   });
 }
-function currentHeadroomAllowlistInputs(fs14, paths, frontDoorLiveness) {
-  const named = frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile));
-  const records = listFrontDoorDirectRecords(fs14, paths.frontdoorDirectRecordsDir);
+function currentHeadroomAllowlistInputs(fs15, paths, frontDoorLiveness) {
+  const named = frontDoorOrigin(readFrontDoorState(fs15, paths.frontdoorStateFile));
+  const records = listFrontDoorDirectRecords(fs15, paths.frontdoorDirectRecordsDir);
   const liveness = frontDoorLiveness(records.map((record) => record.pid));
   const live = liveFrontDoorDirectRecords(records, liveness).map((record) => directOrigin(record.directPort));
   return {
@@ -5907,8 +5968,8 @@ function currentHeadroomAllowlistInputs(fs14, paths, frontDoorLiveness) {
     frontDoorOrigins: [.../* @__PURE__ */ new Set([...named === void 0 ? [] : [named], ...live])].sort()
   };
 }
-function launchRequiredUpstreams(fs14, paths) {
-  const door = frontDoorOrigin(readFrontDoorState(fs14, paths.frontdoorStateFile));
+function launchRequiredUpstreams(fs15, paths) {
+  const door = frontDoorOrigin(readFrontDoorState(fs15, paths.frontdoorStateFile));
   return door === void 0 ? [] : [door];
 }
 async function waitUntilReady(ports, socketPath, pid) {
@@ -6045,6 +6106,29 @@ function isEnoent3(error) {
 function isErrorWithCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
+function writeFileFlushed(file, contents) {
+  const descriptor = fs3.openSync(file, "w", OWNER_ONLY_FILE_MODE);
+  try {
+    fs3.writeFileSync(descriptor, contents, "utf8");
+    fs3.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
+    fs3.fsyncSync(descriptor);
+  } finally {
+    fs3.closeSync(descriptor);
+  }
+}
+function flushDirectory(directory) {
+  const descriptor = fs3.openSync(directory, "r");
+  try {
+    fs3.fsyncSync(descriptor);
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+    if (code === void 0 || !DIRECTORY_FLUSH_UNSUPPORTED_CODES.has(code)) {
+      throw error;
+    }
+  } finally {
+    fs3.closeSync(descriptor);
+  }
+}
 function realSleepSync(ms) {
   refuseToBlockInRole("a synchronous sleep");
   Atomics.wait(new Int32Array(new SharedArrayBuffer(INT32_BYTE_LENGTH)), 0, 0, ms);
@@ -6078,9 +6162,9 @@ function realFrontDoorLiveness(pids) {
     return { status: result.status, stdout: result.stdout, stderr: result.stderr, ...result.error === void 0 ? {} : { error: result.error } };
   });
 }
-async function realRunAsync(command, args) {
-  return await new Promise((resolve) => {
-    execFile(command, [...args], { encoding: "utf8", timeout: PS_TIMEOUT_MS }, (error, stdout, stderr) => {
+function realRunAsyncWithin(timeoutMs) {
+  return async (command, args) => await new Promise((resolve) => {
+    execFile(command, [...args], { encoding: "utf8", timeout: timeoutMs }, (error, stdout, stderr) => {
       resolve({ status: error === null ? 0 : typeof error.code === "number" ? error.code : null, stdout, stderr });
     });
   });
@@ -6286,7 +6370,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, KEY_POLL_MS, CTRL_C_BYTE, realHoldPort, PS_TIMEOUT_MS, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, realLogPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
+var realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, DIRECTORY_FLUSH_UNSUPPORTED_CODES, realFarmFs, INT32_BYTE_LENGTH, KEY_POLL_MS, CTRL_C_BYTE, realHoldPort, PS_TIMEOUT_MS, RUN_OUTPUT_LIMIT_MIB, BYTES_PER_MIB2, RUN_OUTPUT_LIMIT_BYTES, realRunPort, ASYNC_RUN_TIMEOUT_MS, realRunAsync, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, realLogPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
 var init_realPorts = __esm({
   "src/realPorts.ts"() {
     "use strict";
@@ -6325,6 +6409,7 @@ var init_realPorts = __esm({
     OWNER_ONLY_DIR_MODE = 448;
     OWNER_ONLY_FILE_MODE = 384;
     PERMISSION_BITS = 511;
+    DIRECTORY_FLUSH_UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOTSUP", "EOPNOTSUPP"]);
     realFarmFs = {
       lstat(filePath) {
         let stat;
@@ -6381,12 +6466,18 @@ var init_realPorts = __esm({
         fs3.mkdirSync(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
         fs3.chmodSync(dirPath, OWNER_ONLY_DIR_MODE);
       },
-      writeFilePrivate(filePath, contents) {
+      writeFilePrivate(filePath, contents, options) {
         const temp = `${filePath}.${String(process.pid)}.tmp`;
         try {
-          fs3.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-          fs3.chmodSync(temp, OWNER_ONLY_FILE_MODE);
-          fs3.renameSync(temp, filePath);
+          if (options?.durable === true) {
+            writeFileFlushed(temp, contents);
+            fs3.renameSync(temp, filePath);
+            flushDirectory(path15.dirname(filePath));
+          } else {
+            fs3.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+            fs3.chmodSync(temp, OWNER_ONLY_FILE_MODE);
+            fs3.renameSync(temp, filePath);
+          }
         } catch (error) {
           fs3.rmSync(temp, { force: true });
           throw error;
@@ -6456,12 +6547,17 @@ var init_realPorts = __esm({
       }
     };
     PS_TIMEOUT_MS = 2e3;
+    RUN_OUTPUT_LIMIT_MIB = 256;
+    BYTES_PER_MIB2 = 1048576;
+    RUN_OUTPUT_LIMIT_BYTES = RUN_OUTPUT_LIMIT_MIB * BYTES_PER_MIB2;
     realRunPort = {
-      run(command, args) {
-        const result = spawnSyncBlocking("an external command", command, args, { encoding: "utf8" });
+      run(command, args, input) {
+        const result = spawnSyncBlocking("an external command", command, args, { encoding: "utf8", maxBuffer: RUN_OUTPUT_LIMIT_BYTES, ...input === void 0 ? {} : { input } });
         return { status: result.status, stdout: result.stdout, stderr: result.stderr };
       }
     };
+    ASYNC_RUN_TIMEOUT_MS = 2e3;
+    realRunAsync = realRunAsyncWithin(ASYNC_RUN_TIMEOUT_MS);
     MACOS_GUI_SESSION_MANAGER = "Aqua";
     realCredentialPort = {
       readSecretFile(filePath) {
@@ -6653,8 +6749,8 @@ import path18 from "node:path";
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
-function readActiveIdentity(fs14, activeIdentityFile) {
-  const trimmed = fs14.readFileUtf8(activeIdentityFile)?.trim();
+function readActiveIdentity(fs15, activeIdentityFile) {
+  const trimmed = fs15.readFileUtf8(activeIdentityFile)?.trim();
   return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
 }
 function isNonEmpty(value) {
@@ -6704,11 +6800,11 @@ function decideConfigProfile(params) {
   }
   return { source: "none" };
 }
-function loadIdentity(identitiesDir, name, fs14) {
+function loadIdentity(identitiesDir, name, fs15) {
   if (!isFileName(name)) {
     throw new UnsafeNameError(name, "identity", FILE_NAME_RULE);
   }
-  return loadConfigFile(path18.join(identitiesDir, name, "identity.json"), IdentitySchema, fs14.readConfigFile);
+  return loadConfigFile(path18.join(identitiesDir, name, "identity.json"), IdentitySchema, fs15.readConfigFile);
 }
 var IDENTITY_DECISION_SOURCES, IDENTITY_SOURCE_LABELS, CONFIG_PROFILE_DECISION_SOURCES;
 var init_identity = __esm({
@@ -6962,14 +7058,14 @@ function isIdentityName(name) {
 function claudeJsonPath(identitiesDir, identity) {
   return path19.join(identitiesDir, identity, CLAUDE_JSON);
 }
-function readAccountMetadata(fs14, identitiesDir, identity) {
+function readAccountMetadata(fs15, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return readAccountMetadataFile(fs14, claudeJsonPath(identitiesDir, identity));
+  return readAccountMetadataFile(fs15, claudeJsonPath(identitiesDir, identity));
 }
-function readAccountMetadataFile(fs14, file) {
-  const raw = fs14.readFileUtf8(file);
+function readAccountMetadataFile(fs15, file) {
+  const raw = fs15.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -6999,19 +7095,19 @@ function readAccountMetadataFile(fs14, file) {
   }
   return account.data;
 }
-function createAccountReader(fs14, identitiesDir) {
+function createAccountReader(fs15, identitiesDir) {
   const cache = /* @__PURE__ */ new Map();
   return (identity) => {
     if (!isIdentityName(identity)) {
       throw new Error(`"${identity}" is not a valid identity name.`);
     }
-    const stat = fs14.lstat(claudeJsonPath(identitiesDir, identity));
+    const stat = fs15.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(fs14, identitiesDir, identity);
+    const account = readAccountMetadata(fs15, identitiesDir, identity);
     cache.set(identity, { stamp, account });
     return account;
   };
@@ -7047,9 +7143,9 @@ var init_accountDescription = __esm({
 });
 
 // src/identityAccounts.ts
-function readIdentityAccount(fs14, identitiesDir, identity) {
+function readIdentityAccount(fs15, identitiesDir, identity) {
   try {
-    const account = readAccountMetadata(fs14, identitiesDir, identity);
+    const account = readAccountMetadata(fs15, identitiesDir, identity);
     return account === void 0 ? void 0 : { account };
   } catch (error) {
     if (error instanceof AccountMetadataError) {
@@ -7688,8 +7784,8 @@ function segmentDay(epochMs) {
 function segmentName(day, pid) {
   return `${day}.${String(pid)}.jsonl`;
 }
-function listLogSegments(fs14, logDir) {
-  return fs14.readdir(logDir).flatMap((name) => {
+function listLogSegments(fs15, logDir) {
+  return fs15.readdir(logDir).flatMap((name) => {
     const match = SEGMENT_RE.exec(name);
     const day = match?.[1];
     if (day === void 0) {
@@ -7698,15 +7794,15 @@ function listLogSegments(fs14, 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(fs14, logDir, options = {}) {
+function readUsageLog(fs15, logDir, options = {}) {
   const { sinceMs } = options;
   const records = [];
   let invalidLines = 0;
-  for (const segment of listLogSegments(fs14, logDir)) {
+  for (const segment of listLogSegments(fs15, logDir)) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const read = readSegment(fs14, logDir, segment);
+    const read = readSegment(fs15, logDir, segment);
     if (read === void 0) {
       continue;
     }
@@ -7720,8 +7816,8 @@ function readUsageLog(fs14, logDir, options = {}) {
   records.sort((left, right) => left.at.localeCompare(right.at));
   return { records, invalidLines };
 }
-function readSegment(fs14, logDir, segment) {
-  const contents = fs14.readFileUtf8(path20.join(logDir, segment.name));
+function readSegment(fs15, logDir, segment) {
+  const contents = fs15.readFileUtf8(path20.join(logDir, segment.name));
   if (contents === void 0) {
     return void 0;
   }
@@ -7755,9 +7851,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return path20.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs14, snapshotsDir, identity) {
+function readUsageSnapshot(fs15, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs14.readFileUtf8(file);
+  const raw = fs15.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -7773,8 +7869,8 @@ function readUsageSnapshot(fs14, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs14, snapshotsDir) {
-  return fs14.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs15, snapshotsDir) {
+  return fs15.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -7782,7 +7878,7 @@ function listUsageSnapshots(fs14, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs14, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs15, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -7807,11 +7903,11 @@ var init_read = __esm({
 
 // src/usage/store.ts
 import path21 from "node:path";
-function pruneUsageLog(fs14, logDir, nowMs) {
+function pruneUsageLog(fs15, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
-  for (const segment of listLogSegments(fs14, logDir)) {
+  for (const segment of listLogSegments(fs15, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs14.removeRecursive(path21.join(logDir, segment.name));
+      fs15.removeRecursive(path21.join(logDir, segment.name));
     }
   }
 }
@@ -7840,7 +7936,7 @@ function foldProviderState(current, record) {
   };
 }
 function createUsageStore(deps) {
-  const { fs: fs14, paths } = deps;
+  const { fs: fs15, paths } = deps;
   let prunedDay;
   const rewriteSnapshot = (identity, fold) => {
     if (!isIdentityName(identity)) {
@@ -7849,7 +7945,7 @@ function createUsageStore(deps) {
     }
     let current;
     try {
-      current = readUsageSnapshot(fs14, paths.usageSnapshotsDir, identity);
+      current = readUsageSnapshot(fs15, paths.usageSnapshotsDir, identity);
     } catch (error) {
       if (!(error instanceof UsageSnapshotError)) {
         throw error;
@@ -7876,8 +7972,8 @@ function createUsageStore(deps) {
       ...account === void 0 ? {} : { account },
       providers
     });
-    fs14.mkdirPrivate(paths.usageSnapshotsDir);
-    fs14.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
+    fs15.mkdirPrivate(paths.usageSnapshotsDir);
+    fs15.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
 `);
     deps.publish?.(snapshot);
     return true;
@@ -7886,14 +7982,14 @@ function createUsageStore(deps) {
     record: (input) => {
       const record = UsageRecordSchema.parse(input);
       const nowMs = deps.now();
-      fs14.mkdirPrivate(paths.usageDir);
-      fs14.mkdirPrivate(paths.usageLogDir);
+      fs15.mkdirPrivate(paths.usageDir);
+      fs15.mkdirPrivate(paths.usageLogDir);
       const day = segmentDay(nowMs);
       if (prunedDay !== day) {
-        pruneUsageLog(fs14, paths.usageLogDir, nowMs);
+        pruneUsageLog(fs15, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs14.appendFilePrivate(path21.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
+      fs15.appendFilePrivate(path21.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
 `);
       deps.onRecord?.(record);
       if (record.identity !== void 0) {
@@ -7937,14 +8033,14 @@ import { z as z15 } from "zod";
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function loadPoolMembers(fs14, paths, identities, nowMs) {
+function loadPoolMembers(fs15, paths, identities, nowMs) {
   const windowStartMs = nowMs - FIVE_HOUR_WINDOW_MS;
-  const log = readUsageLog(fs14, paths.usageLogDir, { sinceMs: windowStartMs });
+  const log = readUsageLog(fs15, 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(fs14, paths.usageSnapshotsDir, identity);
-      const account = readAccountMetadata(fs14, paths.identitiesDir, identity) ?? snapshot?.account;
+      const snapshot = readUsageSnapshot(fs15, paths.usageSnapshotsDir, identity);
+      const account = readAccountMetadata(fs15, 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) {
@@ -8063,9 +8159,9 @@ function collectPoolIdentities(pools, poolName, stack, found) {
     collectPoolIdentities(pools, nestedName, childStack, found);
   }
 }
-function readPicksFile(fs14, file) {
+function readPicksFile(fs15, file) {
   const empty = { schemaVersion: SCHEMA_VERSION, picks: {} };
-  const raw = fs14.readFileUtf8(file);
+  const raw = fs15.readFileUtf8(file);
   if (raw === void 0) {
     return { file: empty };
   }
@@ -8078,17 +8174,17 @@ function readPicksFile(fs14, 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(fs14, picksFile, directory) {
-  const read = readPicksFile(fs14, picksFile);
+function readStickyPick(fs15, picksFile, directory) {
+  const read = readPicksFile(fs15, picksFile);
   const entry = read.file.picks[directory];
   return { ...entry === void 0 ? {} : { sticky: entry }, ...read.problem === void 0 ? {} : { problem: read.problem } };
 }
-function recordStickyPick(fs14, picksFile, directory, identity, nowMs) {
-  const current = readPicksFile(fs14, picksFile).file.picks;
+function recordStickyPick(fs15, picksFile, directory, identity, nowMs) {
+  const current = readPicksFile(fs15, 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() } } };
-  fs14.mkdirPrivate(path22.dirname(picksFile));
-  fs14.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
+  fs15.mkdirPrivate(path22.dirname(picksFile));
+  fs15.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
 var PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
@@ -8121,9 +8217,9 @@ var init_poolPick = __esm({
 
 // src/statusline/keys.ts
 import { z as z16 } from "zod";
-function valueAt(source, path42) {
+function valueAt(source, path45) {
   let current = source;
-  for (const part of path42) {
+  for (const part of path45) {
     if (!isPlainObject(current)) {
       return void 0;
     }
@@ -8131,14 +8227,14 @@ function valueAt(source, path42) {
   }
   return current;
 }
-function acceptsNull(path42) {
-  const layer = path42.reduceRight((inner, part) => ({ [part]: inner }), null);
+function acceptsNull(path45) {
+  const layer = path45.reduceRight((inner, part) => ({ [part]: inner }), null);
   return StatuslineSchema.safeParse(layer).success;
 }
-function keyOf(path42, declared) {
+function keyOf(path45, declared) {
   const optional = declared instanceof z16.ZodOptional;
   const leaf = optional ? declared.unwrap() : declared;
-  const common = { path: path42.join("."), description: declared.description ?? "", defaultValue: valueAt(STATUSLINE_DEFAULTS, path42), optional, unsettable: acceptsNull(path42) };
+  const common = { path: path45.join("."), description: declared.description ?? "", defaultValue: valueAt(STATUSLINE_DEFAULTS, path45), optional, unsettable: acceptsNull(path45) };
   if (leaf instanceof z16.ZodNumber) {
     return { ...common, kind: "integer", choices: [] };
   }
@@ -8163,7 +8259,7 @@ function keyOf(path42, declared) {
   if (leaf instanceof z16.ZodArray && leaf.element instanceof z16.ZodString) {
     return { ...common, kind: "textList", choices: [] };
   }
-  throw new TypeError(`statusline setting ${path42.join(".")} has a kind the key listing does not describe`);
+  throw new TypeError(`statusline setting ${path45.join(".")} has a kind the key listing does not describe`);
 }
 function walk(shape, prefix) {
   return Object.entries(shape).flatMap(([name, schema]) => schema instanceof z16.ZodObject ? walk(schema.shape, [...prefix, name]) : [keyOf([...prefix, name], schema)]);
@@ -8179,15 +8275,15 @@ var init_keys = __esm({
 });
 
 // src/statusline/change.ts
-function keyNamed(path42) {
-  const found = statuslineKeys().find((key) => key.path === path42);
+function keyNamed(path45) {
+  const found = statuslineKeys().find((key) => key.path === path45);
   if (found === void 0) {
-    throw new UsageError(`"${path42}" is not a statusline setting; \`agent-shim statusline keys\` lists them.`);
+    throw new UsageError(`"${path45}" is not a statusline setting; \`agent-shim statusline keys\` lists them.`);
   }
   return found;
 }
-function setAt(target, path42, value) {
-  const [head, ...rest] = path42;
+function setAt(target, path45, value) {
+  const [head, ...rest] = path45;
   if (head === void 0) {
     return;
   }
@@ -8200,8 +8296,8 @@ function setAt(target, path42, value) {
   target[head] = next;
   setAt(next, rest, value);
 }
-function removeAt(target, path42) {
-  const [head, ...rest] = path42;
+function removeAt(target, path45) {
+  const [head, ...rest] = path45;
   if (head === void 0) {
     return;
   }
@@ -8219,13 +8315,13 @@ function removeAt(target, path42) {
 }
 function applyStatuslineChange(existing, change) {
   const draft = structuredClone(existing ?? {});
-  for (const [path42, value] of Object.entries(change.set ?? {})) {
-    keyNamed(path42);
-    setAt(draft, path42.split("."), value);
+  for (const [path45, value] of Object.entries(change.set ?? {})) {
+    keyNamed(path45);
+    setAt(draft, path45.split("."), value);
   }
-  for (const path42 of change.unset ?? []) {
-    keyNamed(path42);
-    removeAt(draft, path42.split("."));
+  for (const path45 of change.unset ?? []) {
+    keyNamed(path45);
+    removeAt(draft, path45.split("."));
   }
   const result = StatuslineSchema.safeParse(draft);
   if (!result.success) {
@@ -8514,6 +8610,8 @@ function buildLayoutPaths(root) {
     usageAnchorsFile: path23.join(root, "usage", "anchors.json"),
     usageJobsFile: path23.join(root, "usage", "jobs.json"),
     jobLogsDir: path23.join(root, "logs", "jobs"),
+    identityRenamesDir: path23.join(root, "identity-renames"),
+    launchesDir: path23.join(root, "launches"),
     superviseDir: path23.join(root, "supervise"),
     modelMovesDir: path23.join(root, "model-moves"),
     mcpPermissionsFile: path23.join(root, "mcp", "permissions.json")
@@ -9229,7 +9327,12 @@ function readProvider(paths, name) {
   if (!fs7.existsSync(filePath)) {
     return void 0;
   }
-  const raw = JSON.parse(fs7.readFileSync(filePath, "utf8"));
+  let raw;
+  try {
+    raw = JSON.parse(fs7.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw error instanceof SyntaxError ? new ConfigFileNotJsonError(filePath) : error;
+  }
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
@@ -9251,7 +9354,7 @@ function listProviders(paths, onInvalid = reportInvalidProvider) {
     try {
       provider = readProvider(paths, name);
     } catch (error) {
-      if (!(error instanceof ConfigValidationError || error instanceof LegacyProviderFileError || error instanceof UnsafeNameError)) {
+      if (!(error instanceof ConfigValidationError || error instanceof LegacyProviderFileError || error instanceof ConfigFileNotJsonError || error instanceof UnsafeNameError)) {
         throw error;
       }
       onInvalid(name, error.message);
@@ -9597,13 +9700,13 @@ function decideSignIn(facts) {
 function credentialsFilePath(farmRoot) {
   return path25.join(farmRoot, CREDENTIALS_FILE);
 }
-function identitySignIn(fs14, probe, identity) {
+function identitySignIn(fs15, probe, identity) {
   const probing = !identity.hasCredentialBlock && identity.provider === void 0;
   return decideSignIn({
     hasCredentialBlock: identity.hasCredentialBlock,
     provider: identity.provider,
     keychainItem: probing && probe.platform === "darwin" && probe.run !== void 0 ? keychainHasItem(probe.run, identity.farmRoot) : void 0,
-    credentialsFile: probing && fs14.lstat(credentialsFilePath(identity.farmRoot)) !== void 0,
+    credentialsFile: probing && fs15.lstat(credentialsFilePath(identity.farmRoot)) !== void 0,
     platform: probe.platform
   });
 }
@@ -9982,62 +10085,62 @@ var init_signatures = __esm({
 });
 
 // src/codex/anthropic.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var TextBlockSchema, Base64ImageSourceSchema, UrlImageSourceSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultContentBlockSchema, ToolResultBlockSchema, OtherBlockSchema, ContentBlockSchema, MessageSchema, ToolSchema, ToolChoiceSchema, SystemSchema, MessagesRequestSchema, CountTokensRequestSchema;
 var init_anthropic = __esm({
   "src/codex/anthropic.ts"() {
     "use strict";
-    TextBlockSchema = z27.looseObject({ type: z27.literal("text"), text: z27.string() });
-    Base64ImageSourceSchema = z27.looseObject({ type: z27.literal("base64"), media_type: z27.string().min(1), data: z27.string() });
-    UrlImageSourceSchema = z27.looseObject({ type: z27.literal("url"), url: z27.string().min(1) });
-    ImageBlockSchema = z27.looseObject({
-      type: z27.literal("image"),
-      source: z27.union([Base64ImageSourceSchema, UrlImageSourceSchema])
+    TextBlockSchema = z28.looseObject({ type: z28.literal("text"), text: z28.string() });
+    Base64ImageSourceSchema = z28.looseObject({ type: z28.literal("base64"), media_type: z28.string().min(1), data: z28.string() });
+    UrlImageSourceSchema = z28.looseObject({ type: z28.literal("url"), url: z28.string().min(1) });
+    ImageBlockSchema = z28.looseObject({
+      type: z28.literal("image"),
+      source: z28.union([Base64ImageSourceSchema, UrlImageSourceSchema])
     });
-    ToolUseBlockSchema = z27.looseObject({
-      type: z27.literal("tool_use"),
-      id: z27.string().min(1),
-      name: z27.string().min(1),
-      input: z27.unknown()
+    ToolUseBlockSchema = z28.looseObject({
+      type: z28.literal("tool_use"),
+      id: z28.string().min(1),
+      name: z28.string().min(1),
+      input: z28.unknown()
     });
-    ToolResultContentBlockSchema = z27.union([TextBlockSchema, z27.looseObject({ type: z27.string() })]);
-    ToolResultBlockSchema = z27.looseObject({
-      type: z27.literal("tool_result"),
-      tool_use_id: z27.string().min(1),
-      content: z27.union([z27.string(), z27.array(ToolResultContentBlockSchema)]).optional()
+    ToolResultContentBlockSchema = z28.union([TextBlockSchema, z28.looseObject({ type: z28.string() })]);
+    ToolResultBlockSchema = z28.looseObject({
+      type: z28.literal("tool_result"),
+      tool_use_id: z28.string().min(1),
+      content: z28.union([z28.string(), z28.array(ToolResultContentBlockSchema)]).optional()
     });
-    OtherBlockSchema = z27.looseObject({ type: z27.string() });
-    ContentBlockSchema = z27.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
-    MessageSchema = z27.looseObject({
-      role: z27.enum(["user", "assistant", "system"]),
-      content: z27.union([z27.string(), z27.array(ContentBlockSchema)])
+    OtherBlockSchema = z28.looseObject({ type: z28.string() });
+    ContentBlockSchema = z28.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
+    MessageSchema = z28.looseObject({
+      role: z28.enum(["user", "assistant", "system"]),
+      content: z28.union([z28.string(), z28.array(ContentBlockSchema)])
     });
-    ToolSchema = z27.looseObject({
-      name: z27.string().min(1),
-      description: z27.string().optional(),
-      input_schema: z27.record(z27.string(), z27.unknown()).optional()
+    ToolSchema = z28.looseObject({
+      name: z28.string().min(1),
+      description: z28.string().optional(),
+      input_schema: z28.record(z28.string(), z28.unknown()).optional()
     });
-    ToolChoiceSchema = z27.union([
-      z27.looseObject({ type: z27.enum(["auto", "none", "any"]) }),
-      z27.looseObject({ type: z27.literal("tool"), name: z27.string().min(1) })
+    ToolChoiceSchema = z28.union([
+      z28.looseObject({ type: z28.enum(["auto", "none", "any"]) }),
+      z28.looseObject({ type: z28.literal("tool"), name: z28.string().min(1) })
     ]);
-    SystemSchema = z27.union([z27.string(), z27.array(z27.union([TextBlockSchema, OtherBlockSchema]))]);
-    MessagesRequestSchema = z27.looseObject({
-      model: z27.string().optional(),
+    SystemSchema = z28.union([z28.string(), z28.array(z28.union([TextBlockSchema, OtherBlockSchema]))]);
+    MessagesRequestSchema = z28.looseObject({
+      model: z28.string().optional(),
       system: SystemSchema.optional(),
-      messages: z27.array(MessageSchema),
-      tools: z27.array(ToolSchema).optional(),
+      messages: z28.array(MessageSchema),
+      tools: z28.array(ToolSchema).optional(),
       tool_choice: ToolChoiceSchema.optional(),
-      stream: z27.boolean().optional(),
+      stream: z28.boolean().optional(),
       /** `user_id` is stable for one Claude Code session and differs between sessions, which is what makes it the right key for both the backend's prompt cache and its session header. */
-      metadata: z27.looseObject({ user_id: z27.string().optional() }).optional(),
+      metadata: z28.looseObject({ user_id: z28.string().optional() }).optional(),
       /** Claude Code's effort setting. Any string is accepted; the translator honours only the levels the backend understands. */
-      output_config: z27.looseObject({ effort: z27.string().optional() }).optional()
+      output_config: z28.looseObject({ effort: z28.string().optional() }).optional()
     });
-    CountTokensRequestSchema = z27.looseObject({
-      system: z27.unknown().optional(),
-      messages: z27.unknown().optional(),
-      tools: z27.unknown().optional()
+    CountTokensRequestSchema = z28.looseObject({
+      system: z28.unknown().optional(),
+      messages: z28.unknown().optional(),
+      tools: z28.unknown().optional()
     });
   }
 });
@@ -10121,7 +10224,7 @@ var init_translate2 = __esm({
 
 // src/providerCatalogue.ts
 import picomatch4 from "picomatch";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function catalogueCachePath(paths, name) {
   return providerFilePath(paths.catalogueDir, name);
 }
@@ -10157,8 +10260,8 @@ var init_providerCatalogue = __esm({
     CATALOGUE_REQUEST_SECONDS = 10;
     CATALOGUE_REQUEST_TIMEOUT_MS = CATALOGUE_REQUEST_SECONDS * MS_PER_SECOND5;
     CATALOGUE_REFRESH_TIMEOUT_MS = DEFAULT_CANDIDATE_URLS * CATALOGUE_REQUEST_TIMEOUT_MS;
-    CatalogueModelSchema = z28.strictObject({ id: z28.string().min(1), name: z28.string().min(1).optional() });
-    CatalogueCacheSchema = z28.strictObject({ fetchedAt: z28.number(), url: z28.string().min(1), models: z28.array(CatalogueModelSchema) });
+    CatalogueModelSchema = z29.strictObject({ id: z29.string().min(1), name: z29.string().min(1).optional() });
+    CatalogueCacheSchema = z29.strictObject({ fetchedAt: z29.number(), url: z29.string().min(1), models: z29.array(CatalogueModelSchema) });
   }
 });
 
@@ -10465,6 +10568,60 @@ var init_proxyBypass2 = __esm({
   }
 });
 
+// src/replayRun.ts
+function keyOf2(command, args) {
+  return JSON.stringify([command, args]);
+}
+async function recordRuns(decide, runAsync) {
+  const answers = /* @__PURE__ */ new Map();
+  const replay = {
+    run: (command, args) => {
+      const answer = answers.get(keyOf2(command, args));
+      if (answer === void 0) {
+        throw new RunNeededError(command, args);
+      }
+      return answer;
+    }
+  };
+  for (; ; ) {
+    try {
+      decide(replay);
+      return replay;
+    } catch (error) {
+      if (!(error instanceof RunNeededError)) {
+        throw error;
+      }
+      answers.set(keyOf2(error.command, error.args), await runAsync(error.command, error.args));
+    }
+  }
+}
+async function resolveWithAsyncRuns(decide, runAsync) {
+  let result;
+  await recordRuns((run) => {
+    result = { value: decide(run) };
+  }, runAsync);
+  if (result === void 0) {
+    throw new Error("the decision finished without a result");
+  }
+  return result.value;
+}
+var RunNeededError;
+var init_replayRun = __esm({
+  "src/replayRun.ts"() {
+    "use strict";
+    RunNeededError = class extends Error {
+      constructor(command, args) {
+        super(`no recorded answer for ${command} ${args.join(" ")}`);
+        this.command = command;
+        this.args = args;
+        this.name = "RunNeededError";
+      }
+      command;
+      args;
+    };
+  }
+});
+
 // src/update/update.ts
 function compareVersions3(left, right) {
   const parse = (version) => {
@@ -10971,6 +11128,59 @@ var init_cliOverride = __esm({
   }
 });
 
+// src/launcher/launchRecords.ts
+import path38 from "node:path";
+import { z as z36 } from "zod";
+function recordFile(directory, pid, identity) {
+  return path38.join(directory, `${String(pid)}.${identity}${RECORD_SUFFIX}`);
+}
+function readRecord(fs15, directory, name) {
+  if (!name.endsWith(RECORD_SUFFIX)) {
+    return void 0;
+  }
+  const raw = fs15.readFileUtf8(path38.join(directory, name));
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const result = LaunchRecordSchema.safeParse(parsed);
+  return result.success ? result.data : void 0;
+}
+function registerLaunch(fs15, directory, owner, isRunning) {
+  fs15.mkdirPrivate(directory);
+  for (const name of fs15.readdir(directory)) {
+    const record2 = readRecord(fs15, directory, name);
+    if (record2 !== void 0 && !isRunning(record2.pid)) {
+      fs15.removeRecursive(path38.join(directory, name));
+    }
+  }
+  const file = recordFile(directory, owner.pid, owner.identity);
+  const record = { pid: owner.pid, identity: owner.identity, startedAt: new Date(owner.startedAtMs).toISOString() };
+  fs15.writeFilePrivate(file, `${JSON.stringify(record)}
+`);
+  return () => {
+    fs15.removeRecursive(file);
+  };
+}
+var LaunchRecordSchema, RECORD_SUFFIX;
+var init_launchRecords = __esm({
+  "src/launcher/launchRecords.ts"() {
+    "use strict";
+    LaunchRecordSchema = z36.strictObject({
+      /** The launcher's process id, which is what tells a launch in progress from a record a crashed launcher left behind. */
+      pid: z36.number().int().positive(),
+      identity: z36.string().min(1),
+      startedAt: z36.iso.datetime()
+    });
+    RECORD_SUFFIX = ".json";
+  }
+});
+
 // src/headroom/headers.ts
 function mergeAnthropicCustomHeaders(existing, additions) {
   const merged = /* @__PURE__ */ new Map();
@@ -11039,7 +11249,7 @@ var init_settings2 = __esm({
 });
 
 // src/launcher/flags.ts
-import path36 from "node:path";
+import path39 from "node:path";
 function resolveLaunchFlags(params) {
   const statusline = resolveStatuslineSettings(params);
   return {
@@ -11095,7 +11305,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = path36.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = path39.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.kind !== void 0 && params.provider.definition.kind !== "http" ? {} : params.provider.definition.env ?? {};
@@ -11187,7 +11397,7 @@ var init_extraFlags = __esm({
 });
 
 // src/usage/resumeContext.ts
-import path37 from "node:path";
+import path40 from "node:path";
 function projectDirNameOf(cwd) {
   return cwd.replace(/[^A-Za-z0-9]/g, "-");
 }
@@ -11238,15 +11448,15 @@ function contextTokensOfTranscript(text) {
   }
   return void 0;
 }
-function newestTranscript(fs14, projectDir) {
+function newestTranscript(fs15, projectDir) {
   let newest;
   let newestMs = -Infinity;
-  for (const name of fs14.readdir(projectDir)) {
+  for (const name of fs15.readdir(projectDir)) {
     if (!name.endsWith(".jsonl")) {
       continue;
     }
-    const candidate = path37.join(projectDir, name);
-    const stat = fs14.lstat(candidate);
+    const candidate = path40.join(projectDir, name);
+    const stat = fs15.lstat(candidate);
     if (stat?.kind === "file" && stat.mtimeMs > newestMs) {
       newestMs = stat.mtimeMs;
       newest = candidate;
@@ -11254,14 +11464,14 @@ function newestTranscript(fs14, projectDir) {
   }
   return newest;
 }
-function resumedContextTokens(fs14, params) {
+function resumedContextTokens(fs15, params) {
   const target = resumeTargetOf(params.passthrough);
   if (target === void 0) {
     return void 0;
   }
-  const projectDir = path37.join(params.claudeHome, "projects", projectDirNameOf(params.cwd));
-  const file = target.kind === "id" ? path37.join(projectDir, `${target.id}.jsonl`) : newestTranscript(fs14, projectDir);
-  const text = file === void 0 ? void 0 : fs14.readFileUtf8(file);
+  const projectDir = path40.join(params.claudeHome, "projects", projectDirNameOf(params.cwd));
+  const file = target.kind === "id" ? path40.join(projectDir, `${target.id}.jsonl`) : newestTranscript(fs15, projectDir);
+  const text = file === void 0 ? void 0 : fs15.readFileUtf8(file);
   return text === void 0 ? void 0 : contextTokensOfTranscript(text);
 }
 var init_resumeContext = __esm({
@@ -11857,7 +12067,7 @@ var init_launchHook = __esm({
 // src/launcher.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import path38 from "node:path";
+import path41 from "node:path";
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
     return { ok: false, status: 1, message: `agent-shim: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
@@ -11866,7 +12076,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: fs14, proc, log } = params;
+  const { paths, fs: fs15, proc, log } = params;
   if (decided.pool === void 0) {
     return { identityDecision: decided };
   }
@@ -11885,7 +12095,7 @@ function pickFromPool(decided, params, parsedArgv, readOnly) {
     selectedVia: decided.source,
     pools: params.pools,
     paths,
-    fs: fs14,
+    fs: fs15,
     usageFs: farmRuntime.fs,
     cwd: farmRuntime.cwd,
     now: farmRuntime.now,
@@ -11909,7 +12119,7 @@ function pickFromPool(decided, params, parsedArgv, readOnly) {
   };
 }
 function decideLaunch(params, readOnly) {
-  const { paths, fs: fs14, proc, log } = params;
+  const { paths, fs: fs15, proc, log } = params;
   const { env, argv } = proc;
   const parsedArgv = parseLauncherArgv(argv);
   const cliOverride = buildCliOverride({
@@ -11924,7 +12134,7 @@ function decideLaunch(params, readOnly) {
     argv0Identity: params.pickedIdentity ?? parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
-      const raw = fs14.readFileUtf8(paths.activeIdentityFile);
+      const raw = fs15.readFileUtf8(paths.activeIdentityFile);
       if (raw === void 0) {
         return void 0;
       }
@@ -11959,7 +12169,7 @@ function decideLaunch(params, readOnly) {
   }
   let loadedIdentity;
   if (identityDecision.name !== void 0) {
-    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs14);
+    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs15);
     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.`
@@ -11974,7 +12184,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs14.readConfigFile(profileFilePath(paths.configProfilesDir, configProfileDecision.name, `the configuration profile selected via ${configProfileDecision.source}`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs15.readConfigFile(profileFilePath(paths.configProfilesDir, configProfileDecision.name, `the configuration profile selected via ${configProfileDecision.source}`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -11983,7 +12193,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: fs14,
+    port: fs15,
     ...parsedArgv.provider === void 0 || parsedArgv.provider === false ? {} : { cliProvider: parsedArgv.provider },
     ...farmContext === void 0 ? {} : { cascade: farmContext.cascade },
     ...loadedIdentity?.config.provider === void 0 ? {} : { identityProvider: loadedIdentity.config.provider }
@@ -12095,9 +12305,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(fs14.readdir, paths.providersDir).flatMap((name) => {
+  const listedProviders = listProviderNames(fs15.readdir, paths.providersDir).flatMap((name) => {
     try {
-      const definition = loadProvider(paths.providersDir, name, fs14);
+      const definition = loadProvider(paths.providersDir, name, fs15);
       return definition === void 0 ? [] : [[name, definition, parseCatalogueCache(params.fs.readFileUtf8(catalogueCachePath(paths, name)))?.models ?? []]];
     } catch {
       return [];
@@ -12115,7 +12325,7 @@ function decideLaunch(params, readOnly) {
     extraFlags: splitExtraFlags(env.CLAUDE_EXTRA_FLAGS),
     passthrough: withLauncherSettings(params.supervised === void 0 ? parsedArgv.rest : withSupervision(parsedArgv.rest, params.supervised), launcherSettings)
   }) : [...parsedArgv.rest];
-  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path38.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path41.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -12153,6 +12363,19 @@ function decideLaunch(params, readOnly) {
   };
 }
 function prepareLaunch(params) {
+  const removers = [];
+  try {
+    return prepareRegisteredLaunch(params, (remove) => {
+      removers.push(remove);
+    });
+  } catch (error) {
+    for (const remove of removers) {
+      remove();
+    }
+    throw error;
+  }
+}
+function prepareRegisteredLaunch(params, onRecorded) {
   const { paths, proc, log } = params;
   const { env } = proc;
   const decided = decideLaunch(params, false);
@@ -12173,14 +12396,17 @@ function prepareLaunch(params) {
     })
   ];
   let warnings = [];
+  let unregisterLaunch;
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: path38.join(paths.root, "update.check"),
+    checkPath: path41.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
   if (decided.farmContext !== void 0) {
     const { farm: resyncFarmRuntime, identity: resyncIdentity, cascade } = decided.farmContext;
+    unregisterLaunch = registerLaunch(resyncFarmRuntime.fs, paths.launchesDir, { pid: resyncFarmRuntime.lock.pid, identity: resyncIdentity, startedAtMs: resyncFarmRuntime.now() }, resyncFarmRuntime.lock.isRunning);
+    onRecorded(unregisterLaunch);
     let result;
     try {
       result = resyncFarm({
@@ -12198,10 +12424,11 @@ function prepareLaunch(params) {
         classification: resyncFarmRuntime.classification,
         now: resyncFarmRuntime.now,
         uniqueSuffix: resyncFarmRuntime.uniqueSuffix,
+        identityExists: () => loadIdentity(paths.identitiesDir, resyncIdentity, params.fs) !== void 0,
         lock: resyncFarmRuntime.lock
       });
     } catch (error) {
-      if (error instanceof IdentityLockBusyError) {
+      if (error instanceof IdentityLockBusyError || error instanceof IdentityGoneError) {
         log.error(error.message);
         proc.exit(1);
       }
@@ -12261,7 +12488,7 @@ function prepareLaunch(params) {
     proxyBypass: resolvedFlags.proxyBypass,
     ...resolvedFlags.statusline === void 0 ? {} : { statusline: resolvedFlags.statusline }
   });
-  const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
+  const releases = [...unregisterLaunch === void 0 ? [] : [unregisterLaunch], ...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
   const release = () => {
     for (const registered of releases) {
       registered();
@@ -12330,6 +12557,7 @@ var init_launcher = __esm({
     init_argv();
     init_cliOverride();
     init_farm();
+    init_launchRecords();
     init_guard();
     init_identity();
     init_flags();
@@ -12365,12 +12593,12 @@ var init_launcher = __esm({
 });
 
 // src/ownCli.ts
-import path39 from "node:path";
+import path42 from "node:path";
 function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string" ? __AGENT_SHIM_DIST_DIR__ : void 0) {
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return path39.join(distDir, OWN_CLI_FILE_NAME);
+  return path42.join(distDir, OWN_CLI_FILE_NAME);
 }
 var OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
@@ -12388,10 +12616,10 @@ var init_ownCli = __esm({
 });
 
 // src/frontdoor/doorLog.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 function appendDoorLog(paths, line) {
-  fs12.mkdirSync(paths.logsDir, { recursive: true });
-  fs12.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+  fs13.mkdirSync(paths.logsDir, { recursive: true });
+  fs13.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
 }
 var init_doorLog = __esm({
@@ -12416,16 +12644,16 @@ var init_selfIdentity = __esm({
 
 // src/frontdoor/trust.ts
 import { createHash as createHash7 } from "node:crypto";
-import path40 from "node:path";
+import path43 from "node:path";
 function resolveTrustBundle(params) {
-  const { caCertFile, bundlesDir, variable, inherited, fs: fs14 } = params;
-  if (inherited === void 0 || inherited === "" || path40.resolve(inherited) === path40.resolve(caCertFile)) {
+  const { caCertFile, bundlesDir, variable, inherited, fs: fs15 } = params;
+  if (inherited === void 0 || inherited === "" || path43.resolve(inherited) === path43.resolve(caCertFile)) {
     return { path: caCertFile };
   }
-  const caPem = fs14.readFileUtf8(caCertFile);
+  const caPem = fs15.readFileUtf8(caCertFile);
   let inheritedPem;
   try {
-    inheritedPem = fs14.readFileUtf8(inherited);
+    inheritedPem = fs15.readFileUtf8(inherited);
   } catch (error) {
     return {
       path: caCertFile,
@@ -12437,10 +12665,10 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = path40.join(bundlesDir, `${createHash7("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
-  if (!fs14.exists(bundle)) {
-    fs14.mkdirp(bundlesDir);
-    fs14.writeFileAtomic(bundle, combined);
+  const bundle = path43.join(bundlesDir, `${createHash7("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  if (!fs15.exists(bundle)) {
+    fs15.mkdirp(bundlesDir);
+    fs15.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
@@ -12453,7 +12681,7 @@ var init_trust = __esm({
 });
 
 // src/frontdoor/realFrontDoorPort.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 function realEnsurePorts(paths, spawnDaemon) {
   return {
     fs: realFarmFs,
@@ -12479,7 +12707,7 @@ function realEnsurePorts(paths, spawnDaemon) {
       }
     },
     // 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, fs13.readFileSync(paths.frontdoorCaCertFile, "utf8"))
+    verifyListener: (port) => probeFrontDoorSync(port, fs14.readFileSync(paths.frontdoorCaCertFile, "utf8"))
   };
 }
 function realFrontDoorPort(paths, spawnDaemon) {
@@ -12512,10 +12740,10 @@ var init_realFrontDoorPort = __esm({
     init_selfIdentity();
     init_trust();
     realTrustBundleFs = {
-      readFileUtf8: (file) => fs13.readFileSync(file, "utf8"),
-      exists: (file) => fs13.existsSync(file),
+      readFileUtf8: (file) => fs14.readFileSync(file, "utf8"),
+      exists: (file) => fs14.existsSync(file),
       mkdirp: (dir) => {
-        fs13.mkdirSync(dir, { recursive: true });
+        fs14.mkdirSync(dir, { recursive: true });
       },
       writeFileAtomic: (file, contents) => {
         realFarmFs.writeFilePrivate(file, contents);
@@ -12524,53 +12752,9 @@ var init_realFrontDoorPort = __esm({
   }
 });
 
-// src/replayRun.ts
-function keyOf2(command, args) {
-  return JSON.stringify([command, args]);
-}
-async function recordRuns(decide, runAsync) {
-  const answers = /* @__PURE__ */ new Map();
-  const replay = {
-    run: (command, args) => {
-      const answer = answers.get(keyOf2(command, args));
-      if (answer === void 0) {
-        throw new RunNeededError(command, args);
-      }
-      return answer;
-    }
-  };
-  for (; ; ) {
-    try {
-      decide(replay);
-      return replay;
-    } catch (error) {
-      if (!(error instanceof RunNeededError)) {
-        throw error;
-      }
-      answers.set(keyOf2(error.command, error.args), await runAsync(error.command, error.args));
-    }
-  }
-}
-var RunNeededError;
-var init_replayRun = __esm({
-  "src/replayRun.ts"() {
-    "use strict";
-    RunNeededError = class extends Error {
-      constructor(command, args) {
-        super(`no recorded answer for ${command} ${args.join(" ")}`);
-        this.command = command;
-        this.args = args;
-        this.name = "RunNeededError";
-      }
-      command;
-      args;
-    };
-  }
-});
-
 // src/launchWiring.ts
 import os8 from "node:os";
-import path41 from "node:path";
+import path44 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function buildFarmRuntime(paths, cwd, run = realRunPort) {
   const home = os8.homedir();
@@ -12625,7 +12809,7 @@ function realPrepareLaunchParams(paths, options) {
     frontdoor: realFrontDoorPort(paths, options.spawnDaemon),
     credentials: { ...realCredentialPort, cache: realCredentialCacheEnv(paths) },
     hold: realHoldPort,
-    hasStoredLogin: (identity) => identitySignIn(realFarmFs, { platform: process.platform, run: options.run ?? realRunPort }, { farmRoot: path41.join(paths.identitiesDir, identity), hasCredentialBlock: false, provider: void 0 }).state !== "signed-out",
+    hasStoredLogin: (identity) => identitySignIn(realFarmFs, { platform: process.platform, run: options.run ?? realRunPort }, { farmRoot: path44.join(paths.identitiesDir, identity), hasCredentialBlock: false, provider: void 0 }).state !== "signed-out",
     ...farm.directoryIdentity === void 0 ? {} : { directoryPinnedIdentity: farm.directoryIdentity },
     ...farm.directoryConfigProfile === void 0 ? {} : { directoryRuleConfigProfile: farm.directoryConfigProfile },
     ...farm.globalDefaultConfigProfile === void 0 ? {} : { globalDefaultConfigProfile: farm.globalDefaultConfigProfile },
@@ -12910,7 +13094,7 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 var MS_PER_SECOND9, SECONDS_PER_HOUR3, HOURS_PER_DAY6, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY2, OpenRouterKeySchema, OpenRouterCreditsSchema, ANTIGRAVITY_HOST, ANTIGRAVITY_QUOTA_URL, ANTIGRAVITY_USER_URL, FIVE_HOURS2, DAYS_PER_WEEK2, FIVE_HOURS_MS, WEEK_MS, AntigravityBucketSchema, AntigravitySummarySchema, GoogleTokenInfoSchema, AntigravityUserSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
@@ -12929,35 +13113,35 @@ var init_providerQuota = __esm({
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR3 * MS_PER_SECOND9],
       [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9]
     ]);
-    ZaiLimitSchema = z35.object({
-      type: z35.string(),
-      unit: z35.number().int(),
-      number: z35.number().int().positive(),
-      percentage: z35.number().nonnegative(),
-      nextResetTime: z35.number().positive().optional(),
-      usage: z35.number().nonnegative().optional(),
-      currentValue: z35.number().nonnegative().optional(),
-      remaining: z35.number().nonnegative().optional()
+    ZaiLimitSchema = z37.object({
+      type: z37.string(),
+      unit: z37.number().int(),
+      number: z37.number().int().positive(),
+      percentage: z37.number().nonnegative(),
+      nextResetTime: z37.number().positive().optional(),
+      usage: z37.number().nonnegative().optional(),
+      currentValue: z37.number().nonnegative().optional(),
+      remaining: z37.number().nonnegative().optional()
     });
-    ZaiResponseSchema = z35.object({
-      success: z35.boolean(),
-      msg: z35.string().optional(),
-      data: z35.object({ level: z35.string().optional(), limits: z35.array(ZaiLimitSchema) })
+    ZaiResponseSchema = z37.object({
+      success: z37.boolean(),
+      msg: z37.string().optional(),
+      data: z37.object({ level: z37.string().optional(), limits: z37.array(ZaiLimitSchema) })
     });
     OPENROUTER_HOST = "openrouter.ai";
     OPENROUTER_KEY_URL = `https://${OPENROUTER_HOST}/api/v1/key`;
     OPENROUTER_CREDITS_URL = `https://${OPENROUTER_HOST}/api/v1/credits`;
     MS_PER_DAY2 = HOURS_PER_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
-    OpenRouterKeySchema = z35.object({
-      data: z35.object({
-        limit: z35.number().nonnegative().nullable(),
-        limit_remaining: z35.number().nullable(),
-        limit_reset: z35.string().nullable(),
-        is_free_tier: z35.boolean().optional(),
-        free_model_daily_requests: z35.object({ used: z35.number().nonnegative(), limit: z35.number().nonnegative(), remaining: z35.number() }).optional()
+    OpenRouterKeySchema = z37.object({
+      data: z37.object({
+        limit: z37.number().nonnegative().nullable(),
+        limit_remaining: z37.number().nullable(),
+        limit_reset: z37.string().nullable(),
+        is_free_tier: z37.boolean().optional(),
+        free_model_daily_requests: z37.object({ used: z37.number().nonnegative(), limit: z37.number().nonnegative(), remaining: z37.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = z35.object({ data: z35.object({ total_credits: z35.number().nonnegative(), total_usage: z35.number().nonnegative() }) });
+    OpenRouterCreditsSchema = z37.object({ data: z37.object({ total_credits: z37.number().nonnegative(), total_usage: z37.number().nonnegative() }) });
     ANTIGRAVITY_HOST = "daily-cloudcode-pa.googleapis.com";
     ANTIGRAVITY_QUOTA_URL = `https://${ANTIGRAVITY_HOST}/v1internal:retrieveUserQuotaSummary`;
     ANTIGRAVITY_USER_URL = `https://${ANTIGRAVITY_HOST}/v1internal:loadCodeAssist`;
@@ -12965,21 +13149,21 @@ var init_providerQuota = __esm({
     DAYS_PER_WEEK2 = 7;
     FIVE_HOURS_MS = FIVE_HOURS2 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
     WEEK_MS = DAYS_PER_WEEK2 * HOURS_PER_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
-    AntigravityBucketSchema = z35.object({
-      bucketId: z35.string(),
-      remainingFraction: z35.number().optional(),
-      resetTime: z35.string().optional()
+    AntigravityBucketSchema = z37.object({
+      bucketId: z37.string(),
+      remainingFraction: z37.number().optional(),
+      resetTime: z37.string().optional()
     });
-    AntigravitySummarySchema = z35.object({ groups: z35.array(z35.object({ buckets: z35.array(AntigravityBucketSchema) })) });
-    GoogleTokenInfoSchema = z35.object({
-      email: z35.string().optional(),
-      sub: z35.string().optional()
+    AntigravitySummarySchema = z37.object({ groups: z37.array(z37.object({ buckets: z37.array(AntigravityBucketSchema) })) });
+    GoogleTokenInfoSchema = z37.object({
+      email: z37.string().optional(),
+      sub: z37.string().optional()
     });
-    AntigravityUserSchema = z35.object({
+    AntigravityUserSchema = z37.object({
       /** The code-assist tier context, which defaults to the free tier for every account. */
-      currentTier: z35.object({ name: z35.string().optional(), id: z35.string().optional() }).optional(),
+      currentTier: z37.object({ name: z37.string().optional(), id: z37.string().optional() }).optional(),
       /** The account's paid subscription; absent when the account has none. */
-      paidTier: z35.object({ name: z35.string().optional(), id: z35.string().optional() }).optional()
+      paidTier: z37.object({ name: z37.string().optional(), id: z37.string().optional() }).optional()
     });
   }
 });
@@ -13358,8 +13542,8 @@ function pathnameOf(url) {
   return new URL(url ?? "/", "http://127.0.0.1").pathname;
 }
 function isRcSessionExchange(url) {
-  const path42 = pathnameOf(url);
-  return path42 === RC_SESSIONS_PATH_PREFIX || path42.startsWith(`${RC_SESSIONS_PATH_PREFIX}/`);
+  const path45 = pathnameOf(url);
+  return path45 === RC_SESSIONS_PATH_PREFIX || path45.startsWith(`${RC_SESSIONS_PATH_PREFIX}/`);
 }
 var RC_SESSION_ID_PREFIX = "cse_";
 var RC_IDLE_EXPIRY_MS = 45e3;
@@ -13918,8 +14102,8 @@ var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
 function isRcReadFileEncoding(value) {
   return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value);
 }
-function buildRcReadFilePayload(requestId, path42, options) {
-  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path42, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+function buildRcReadFilePayload(requestId, path45, options) {
+  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path45, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
 }
 function buildRcFileSuggestionsPayload(requestId, query) {
   return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
@@ -14021,15 +14205,15 @@ async function getRcSessionContextUsage(deps, sessionId, detail) {
   const result = await deliverRcClientPayload(deps, sessionId, buildRcGetContextUsagePayload(requestId, detail), `request the context usage of session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
-async function readRcSessionFile(deps, sessionId, path42, options) {
-  if (path42 === "") {
+async function readRcSessionFile(deps, sessionId, path45, options) {
+  if (path45 === "") {
     return { ok: false, message: "a read-file write needs a non-empty path: the SDK's own field names the file the worker resolves against the session's cwd, and an empty string names none" };
   }
   if (options?.maxBytes !== void 0 && (!Number.isInteger(options.maxBytes) || options.maxBytes <= 0)) {
     return { ok: false, message: "a read-file write's max-bytes is a positive whole number of bytes: the SDK's own field caps the read, and a zero or negative cap reads nothing" };
   }
   const requestId = deps.newUuid();
-  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path42, options), `read ${path42} from session ${sessionId}`);
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path45, options), `read ${path45} from session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
 async function suggestRcSessionFiles(deps, sessionId, query) {
@@ -14198,11 +14382,11 @@ function createRcControlHandler(deps) {
       path: "read-file",
       read: (body) => {
         const session = bodyString(body, "session");
-        const path42 = bodyString(body, "path");
+        const path45 = bodyString(body, "path");
         const maxBytes = "maxBytes" in body ? bodyPositiveInteger(body, "maxBytes") : void 0;
         const encoding = "encoding" in body && isRcReadFileEncoding(body.encoding) ? body.encoding : void 0;
-        const refused2 = session === void 0 || path42 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
-        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path42, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+        const refused2 = session === void 0 || path45 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
+        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path45, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
       }
     },
     {
@@ -14512,9 +14696,9 @@ function requestIdOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path42, what) => {
+  const listAnswerOf = async (path45, what) => {
     try {
-      return await transport.request({ method: "GET", path: path42, headers });
+      return await transport.request({ method: "GET", path: path45, headers });
     } catch (error) {
       throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -14586,10 +14770,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path42, body, describeFailure2) => {
+  const writeOf = async (path45, body, describeFailure2) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path42, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path45, headers: { ...headers, "content-type": "application/json" }, body });
     } catch (error) {
       return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -14620,10 +14804,10 @@ function frontDoorRcControl(transport, token) {
     endSession: async (sessionId, reason) => await writeOf(`${CONTROL_PATH_PREFIX}/end-session`, JSON.stringify({ session: sessionId, ...reason === void 0 ? {} : { reason } }), (status, message) => `ending ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getUsage: async (sessionId, skipBehaviors) => await writeOf(`${CONTROL_PATH_PREFIX}/get-usage`, JSON.stringify({ session: sessionId, ...skipBehaviors === void 0 ? {} : { skipBehaviors } }), (status, message) => `requesting the usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getContextUsage: async (sessionId, detail) => await writeOf(`${CONTROL_PATH_PREFIX}/get-context-usage`, JSON.stringify({ session: sessionId, ...detail === void 0 ? {} : { detail } }), (status, message) => `requesting the context usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    readFile: async (sessionId, path42, options) => await writeOf(
+    readFile: async (sessionId, path45, options) => await writeOf(
       `${CONTROL_PATH_PREFIX}/read-file`,
-      JSON.stringify({ session: sessionId, path: path42, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
-      (status, message) => `reading ${path42} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+      JSON.stringify({ session: sessionId, path: path45, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
+      (status, message) => `reading ${path45} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
     ),
     fileSuggestions: async (sessionId, query) => await writeOf(`${CONTROL_PATH_PREFIX}/file-suggestions`, JSON.stringify({ session: sessionId, query }), (status, message) => `requesting file suggestions from ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     keepAlive: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/keep-alive`, JSON.stringify({ session: sessionId }), (status, message) => `keeping ${sessionId} alive failed (HTTP ${String(status)}): ${message}`),
@@ -14782,12 +14966,12 @@ function tlsFacts(options) {
 }
 function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const post = async (path42, headers, body) => await new Promise((resolve, reject) => {
+  const post = async (path45, headers, body) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method: "POST",
-      path: path42,
+      path: path45,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
       agent
@@ -14852,12 +15036,12 @@ function lateRcStreamDial(resolve) {
 }
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path42, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path45, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path42,
+      path: path45,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, ...body === void 0 ? {} : { "content-length": String(Buffer.byteLength(body, "utf8")) } },
       agent,
@@ -14899,9 +15083,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path42 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const path45 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
       const streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
-      const { status, response } = await request4("GET", path42, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path45, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -15151,11 +15335,11 @@ function credentialOfJson(parsed) {
 function sequenceNumOfJson(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
 }
-function createRcCredentialStore(fs14, dir) {
-  fs14.mkdirPrivate(dir);
+function createRcCredentialStore(fs15, dir) {
+  fs15.mkdirPrivate(dir);
   const fileFor = (sessionId) => path11.join(dir, `${sessionId}.json`);
   const readParsed = (sessionId) => {
-    const raw = fs14.readFileUtf8(fileFor(sessionId));
+    const raw = fs15.readFileUtf8(fileFor(sessionId));
     if (raw === void 0) {
       return void 0;
     }
@@ -15180,7 +15364,7 @@ function createRcCredentialStore(fs14, dir) {
       }
       const cursor = sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
       const record = { ...credential, ...cursor === void 0 ? {} : { highestSequenceNum: cursor } };
-      fs14.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
+      fs15.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
 `);
     },
     readCursor: (sessionId) => {
@@ -15195,14 +15379,14 @@ function createRcCredentialStore(fs14, dir) {
       }
       const credential = credentialOfJson(readParsed(sessionId));
       const record = credential === void 0 ? { highestSequenceNum } : { ...credential, highestSequenceNum };
-      fs14.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
+      fs15.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record, null, 2)}
 `);
     },
     remove: (sessionId) => {
       if (!isSafeSessionId(sessionId)) {
         return;
       }
-      fs14.removeRecursive(fileFor(sessionId));
+      fs15.removeRecursive(fileFor(sessionId));
     }
   };
 }
@@ -15894,19 +16078,19 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk2 = (current, path42) => {
+  const walk2 = (current, path45) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
       if (nested === name) {
-        return [...path42, nested];
+        return [...path45, nested];
       }
-      if (path42.includes(nested)) {
+      if (path45.includes(nested)) {
         continue;
       }
-      const found = walk2(nested, [...path42, nested]);
+      const found = walk2(nested, [...path45, nested]);
       if (found !== void 0) {
         return found;
       }
@@ -16346,7 +16530,7 @@ function loadCheckProvider(paths, name) {
   try {
     definition = readProvider(paths, name);
   } catch (error) {
-    if (error instanceof ConfigValidationError || error instanceof LegacyProviderFileError) {
+    if (error instanceof ConfigValidationError || error instanceof LegacyProviderFileError || error instanceof ConfigFileNotJsonError) {
       return { name, problem: error.message };
     }
     throw error;
@@ -16618,8 +16802,8 @@ var ResetRowSchema = z22.strictObject({
 var ResetScheduleSchema = z22.strictObject({ resets: z22.readonly(z22.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
-import path30 from "node:path";
-import { z as z29 } from "zod";
+import path32 from "node:path";
+import { z as z30 } from "zod";
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -16628,13 +16812,211 @@ init_store();
 
 // src/identityStore.ts
 init_load();
+init_names();
 init_store();
 init_schema();
 init_cliError();
 init_identity();
-import fs9 from "node:fs";
-import path28 from "node:path";
+import fs10 from "node:fs";
+import path30 from "node:path";
 init_lock();
+
+// src/identityRenameJournal.ts
+init_cliError();
+import path28 from "node:path";
+import { z as z24 } from "zod";
+var RenameJournalSchema = z24.strictObject({
+  version: z24.literal(1),
+  from: z24.string().min(1),
+  to: z24.string().min(1),
+  startedAt: z24.iso.datetime(),
+  /** The process that began the rename, for a person reading the file. Whether it is still running is told by the locks, not by this. */
+  pid: z24.number().int().positive(),
+  steps: z24.array(
+    z24.strictObject({
+      description: z24.string().min(1),
+      /** Whether the step has been applied and marked so. */
+      done: z24.boolean(),
+      /** Whether the step was begun: written ahead of the step, before it runs, so a process that dies after the step took effect and before `done` was written still leaves a record that it may have. */
+      started: z24.boolean()
+    })
+  )
+});
+var JOURNAL_SUFFIX = ".json";
+var RenameJournalUnreadableError = class extends CliError {
+  constructor(file, detail) {
+    super(`${file} is not a rename journal this agent-shim can read (${detail}). If no rename was left unfinished, remove it; otherwise look at what it names before renaming anything.`);
+    this.detail = detail;
+    this.name = "RenameJournalUnreadableError";
+  }
+  detail;
+};
+function readRenameJournal(fs15, file) {
+  const raw = fs15.readFileUtf8(file);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new RenameJournalUnreadableError(file, "not valid JSON");
+  }
+  const result = RenameJournalSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new RenameJournalUnreadableError(file, result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; "));
+  }
+  return result.data;
+}
+function listRenameJournals(fs15, directory) {
+  const journals = [];
+  const unreadable = [];
+  for (const name of [...fs15.readdir(directory)].sort()) {
+    if (!name.endsWith(JOURNAL_SUFFIX)) {
+      continue;
+    }
+    const file = path28.join(directory, name);
+    try {
+      const journal = readRenameJournal(fs15, file);
+      if (journal !== void 0) {
+        journals.push(journal);
+      }
+    } catch (error) {
+      if (!(error instanceof RenameJournalUnreadableError)) {
+        throw error;
+      }
+      unreadable.push({ file, detail: error.detail });
+    }
+  }
+  return { journals, unreadable };
+}
+function stepMayBeApplied(step) {
+  return step.done || step.started;
+}
+function recordsNothingApplied(journal) {
+  return !journal.steps.some(stepMayBeApplied);
+}
+function describeUnfinishable(bothExist) {
+  return bothExist ? "both names are identities" : "there is no identity under either name";
+}
+function finishabilityOf(journal, exists) {
+  const underFrom = exists(journal.from);
+  if (underFrom === exists(journal.to)) {
+    return { finishable: false, reason: describeUnfinishable(underFrom) };
+  }
+  return underFrom && recordsNothingApplied(journal) ? { finishable: true, discardable: true } : { finishable: true };
+}
+function discardJournalCommand(journal) {
+  return `agent-shim identity rename ${journal.from} ${journal.to} --discard-journal`;
+}
+function describeUnfinishedRename(journal, finishability) {
+  const applied = journal.steps.filter(stepMayBeApplied).length;
+  const progress = `an unfinished rename of identity "${journal.from}" to "${journal.to}" (${String(applied)} of ${String(journal.steps.length)} steps recorded as begun or done)`;
+  return finishability.finishable ? `${progress}. Finish it with \`agent-shim identity rename ${journal.from} ${journal.to}\`; to put the name back afterwards, run \`agent-shim identity rename ${journal.to} ${journal.from}\`.${finishability.discardable === true ? ` No step is recorded as begun or done and the identity is still under "${journal.from}", so its record can be discarded with \`${discardJournalCommand(journal)}\`; that removes only the record.` : ""}` : `${progress} that cannot be finished: ${finishability.reason}. If nothing is left of it to keep, discard its record with \`${discardJournalCommand(journal)}\`; that removes only the record and changes no identity.`;
+}
+var NameHeldByUnfinishedRenameError = class extends CliError {
+  constructor(action, name, journal, finishability) {
+    super(`Cannot ${action} identity "${name}": there is ${describeUnfinishedRename(journal, finishability)}`);
+    this.name = "NameHeldByUnfinishedRenameError";
+  }
+};
+function requireNameFreeOfUnfinishedRename(fs15, directory, name, action, sameName, exists) {
+  const held = listRenameJournals(fs15, directory).journals.find((journal) => [journal.from, journal.to].some((heldName) => heldName === name || sameName(name, heldName)));
+  if (held !== void 0) {
+    throw new NameHeldByUnfinishedRenameError(action, name, held, finishabilityOf(held, exists));
+  }
+}
+
+// src/keychainLogin.ts
+init_cliError();
+init_signIn();
+var ITEM_NOT_FOUND_STATUS = 44;
+var MAX_DETAIL_CHARS = 200;
+var CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
+var KeychainLoginError = class extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "KeychainLoginError";
+  }
+};
+var KeychainLookupError = class extends KeychainLoginError {
+  constructor(message) {
+    super(message);
+    this.name = "KeychainLookupError";
+  }
+};
+function statusPhrase(status) {
+  return status === null ? "without a status" : String(status);
+}
+function describe(stderr) {
+  const [first] = stderr.trim().split("\n");
+  return first === void 0 || first === "" ? "" : ` (${first.slice(0, MAX_DETAIL_CHARS)})`;
+}
+function lookup(run, service) {
+  const result = run.run("security", ["find-generic-password", "-s", service]);
+  if (result.status === 0) {
+    return { found: true, attributes: result.stdout };
+  }
+  if (result.status === ITEM_NOT_FOUND_STATUS) {
+    return { found: false };
+  }
+  throw new KeychainLookupError(`Could not look up the Keychain item ${service}: security exited ${statusPhrase(result.status)}${describe(result.stderr)}.`);
+}
+function plainAccountOf(attributes) {
+  const line = attributes.split("\n").find((candidate) => candidate.includes('"acct"<blob>='));
+  const value = line?.slice(line.indexOf("=") + 1).trim();
+  const name = value === void 0 ? void 0 : /^"([^"\\]*)"$/u.exec(value)?.[1];
+  return name === void 0 || name === "" || CONTROL_CHARACTER.test(name) ? void 0 : name;
+}
+function keychainDeleteCommand(service, account) {
+  return `security delete-generic-password -s ${shellQuoted(service)}${account === void 0 ? "" : ` -a ${shellQuoted(account)}`}`;
+}
+function shellQuoted(value) {
+  return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+var KEEP_KEYCHAIN_LOGIN_DESCRIPTION = "Create the identity even though the macOS Keychain already holds a Claude Code login filed for its directory (left by an identity of that name that was renamed or removed); the identity starts signed in as that account. If another identity holds that login, the two share it. Without it that login is refused and the command that deletes it is printed.";
+function requireNoLeftoverKeychainLogin(keychain, configDir, name, keepLogin) {
+  if (keepLogin || keychain.platform !== "darwin") {
+    return;
+  }
+  const service = claudeCodeKeychainService(configDir);
+  const found = lookup(keychain.run, service);
+  if (!found.found) {
+    return;
+  }
+  const account = plainAccountOf(found.attributes);
+  throw new KeychainLoginError(
+    `Cannot create identity "${name}": the Keychain already holds a Claude Code login filed for ${configDir} (service ${service}${account === void 0 ? "" : `, account ${account}`}), left behind by an identity of that name that was renamed or removed. A new identity there would start signed in as that account. If you do not need it, delete it with \`${keychainDeleteCommand(service, account)}\` and run the command again. To create the identity signed in as that account on purpose, run \`agent-shim identity add ${name} --keep-keychain-login\`. If another identity holds a copy of that login, as a renamed identity does when its old item could not be deleted, keeping it makes the two share one login.`
+  );
+}
+
+// src/sameDirectory.ts
+import fs9 from "node:fs";
+import path29 from "node:path";
+function sameDirectory(first, second) {
+  const a = fs9.statSync(first, { throwIfNoEntry: false });
+  const b = fs9.statSync(second, { throwIfNoEntry: false });
+  if (a === void 0 || b === void 0) {
+    return false;
+  }
+  return a.dev === b.dev && a.ino === b.ino;
+}
+function caseSwapped(name) {
+  return name.replace(/[A-Za-z]/gu, (letter) => letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase());
+}
+function ignoresCase(directory) {
+  if (!fs9.existsSync(directory)) {
+    return false;
+  }
+  const probe = fs9.mkdtempSync(path29.join(directory, ".case-probe-"));
+  try {
+    return sameDirectory(probe, path29.join(directory, caseSwapped(path29.basename(probe))));
+  } finally {
+    fs9.rmSync(probe, { recursive: true, force: true });
+  }
+}
+
+// src/identityStore.ts
 var IdentityNotFoundError = class extends CliError {
   constructor(name) {
     super(`No identity named "${name}". Run \`agent-shim identity add ${name}\` first.`);
@@ -16662,7 +17044,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return path28.join(paths.identitiesDir, name, "identity.json");
+  return path30.join(paths.identitiesDir, name, "identity.json");
 }
 function requireIdentityNames(paths, names) {
   const existing = new Set(listIdentities(paths).map((entry) => entry.name));
@@ -16673,21 +17055,23 @@ function requireIdentityNames(paths, names) {
   }
 }
 function identityExists(paths, name) {
-  return fs9.existsSync(identityJsonPath(paths, name));
+  return fs10.existsSync(identityJsonPath(paths, name));
 }
 function readIdentity(paths, name) {
   return readJson(identityJsonPath(paths, name), IdentitySchema);
 }
-function addIdentity(paths, name) {
+function requireIdentityCreatable(paths, name) {
+  requireNoUnfinishedRenameNaming(paths, name, "add");
   if (identityExists(paths, name)) {
     throw new IdentityAlreadyExistsError(name);
   }
-  const parsed = IdentitySchema.safeParse({ name, allowAmbientCredential: false });
-  if (!parsed.success) {
-    throw new InvalidIdentityNameError(name);
-  }
-  writeJsonAtomic(identityJsonPath(paths, name), parsed.data);
-  return parsed.data;
+  requireNewIdentityName(name);
+}
+function addIdentity(paths, name) {
+  requireIdentityCreatable(paths, name);
+  const identity = IdentitySchema.parse({ name, allowAmbientCredential: false });
+  writeJsonAtomic(identityJsonPath(paths, name), identity);
+  return identity;
 }
 function useIdentity(paths, name) {
   const pool = poolNameOf(name);
@@ -16700,33 +17084,89 @@ function useIdentity(paths, name) {
 `);
 }
 function readActiveIdentity2(paths) {
-  if (!fs9.existsSync(paths.activeIdentityFile)) {
+  if (!fs10.existsSync(paths.activeIdentityFile)) {
     return void 0;
   }
-  const raw = fs9.readFileSync(paths.activeIdentityFile, "utf8").trim();
+  const raw = fs10.readFileSync(paths.activeIdentityFile, "utf8").trim();
   return raw === "" ? void 0 : raw;
 }
 function isIdentityDirectoryName(name) {
   return !name.startsWith(".");
 }
+var UNREACHABLE_CODES = /* @__PURE__ */ new Set(["ELOOP", "EACCES", "ENOTDIR"]);
+function systemErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function unreachableCodeOf(error) {
+  const code = systemErrorCode(error);
+  if (code === "ENOENT") {
+    return void 0;
+  }
+  if (code !== void 0 && UNREACHABLE_CODES.has(code)) {
+    return code;
+  }
+  throw error;
+}
+function followedLink(link) {
+  try {
+    return fs10.statSync(link).isDirectory() ? "directory" : "other";
+  } catch (error) {
+    const code = unreachableCodeOf(error);
+    return code === void 0 ? "other" : { code };
+  }
+}
+function entryRefusal(directory) {
+  try {
+    fs10.accessSync(directory, fs10.constants.X_OK);
+    return void 0;
+  } catch (error) {
+    return unreachableCodeOf(error);
+  }
+}
+function listIdentityDirectories(paths) {
+  const names = [];
+  const unreachable = [];
+  if (fs10.existsSync(paths.identitiesDir)) {
+    for (const entry of fs10.readdirSync(paths.identitiesDir, { withFileTypes: true })) {
+      if (!isIdentityDirectoryName(entry.name)) {
+        continue;
+      }
+      const entryPath = path30.join(paths.identitiesDir, entry.name);
+      const followed = entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? followedLink(entryPath) : "other";
+      if (followed === "other") {
+        continue;
+      }
+      const code = followed === "directory" ? entryRefusal(entryPath) : followed.code;
+      if (code === void 0) {
+        names.push(entry.name);
+      } else {
+        unreachable.push({ name: entry.name, code });
+      }
+    }
+  }
+  return { names: names.sort(), unreachable: unreachable.sort((a, b) => a.name.localeCompare(b.name)) };
+}
+var NOT_JSON_PROBLEM = "is not valid JSON";
 function readIdentityForListing(paths, name) {
   try {
     return readIdentity(paths, name);
   } catch (error) {
-    if (error instanceof ConfigValidationError || error instanceof SyntaxError) {
+    if (error instanceof ConfigFileNotJsonError) {
+      return { problem: NOT_JSON_PROBLEM };
+    }
+    if (error instanceof ConfigValidationError) {
       return { problem: error.message.replace(/\s*\n\s*/g, " ") };
     }
     throw error;
   }
 }
 function listIdentities(paths) {
-  if (!fs9.existsSync(paths.identitiesDir)) {
+  if (!fs10.existsSync(paths.identitiesDir)) {
     return [];
   }
   const active = readActiveIdentity2(paths);
-  const names = fs9.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort();
   const result = [];
-  for (const name of names) {
+  for (const name of listIdentityDirectories(paths).names) {
     const read = readIdentityForListing(paths, name);
     if (read === void 0) {
       continue;
@@ -16736,6 +17176,10 @@ function listIdentities(paths) {
   }
   return result;
 }
+function requireIdentityAddable(paths, name, keychain, keepKeychainLogin) {
+  requireIdentityCreatable(paths, name);
+  requireNoLeftoverKeychainLogin(keychain, path30.join(paths.identitiesDir, name), name, keepKeychainLogin);
+}
 function setIdentityAnchors(paths, identityName, anchors) {
   if (!identityExists(paths, identityName)) {
     throw new IdentityNotFoundError(identityName);
@@ -16788,50 +17232,70 @@ function setIdentityCredential(paths, identityName, change) {
     credential: { sources: [...sources], ...target === void 0 ? {} : { target }, ...cache === void 0 ? {} : { cache } }
   });
 }
+var UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var FARM_SUFFIX_PATTERN = `\\.(?:scratch|previous)\\.\\d+\\.${UUID_PATTERN}`;
+function escapedForPattern(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function isFarmEntry(entry, name) {
+  return entry === name || new RegExp(`^\\.${escapedForPattern(name)}${FARM_SUFFIX_PATTERN}$`, "u").test(entry);
+}
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === path28.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return isFarmEntry(entry, name) || entry === path30.basename(identityLockPath("", name));
+}
+function requireNewIdentityName(name) {
+  if (!FileNameSchema.safeParse(name).success) {
+    throw new InvalidIdentityNameError(name);
+  }
+}
+function sameIdentityName(paths, first, second) {
+  return sameDirectory(path30.join(paths.identitiesDir, first), path30.join(paths.identitiesDir, second)) || first.toLowerCase() === second.toLowerCase() && ignoresCase(paths.identitiesDir);
+}
+function requireNoUnfinishedRenameNaming(paths, name, action) {
+  requireNameFreeOfUnfinishedRename({ readFileUtf8: nodeStoreFs.readFileUtf8, readdir: (directory) => fs10.existsSync(directory) ? fs10.readdirSync(directory) : [] }, paths.identityRenamesDir, name, action, (first, second) => sameIdentityName(paths, first, second), (identity) => identityExists(paths, identity));
 }
 function removeIdentity(paths, name) {
+  requireNoUnfinishedRenameNaming(paths, name, "remove");
   if (!identityExists(paths, name)) {
     throw new IdentityNotFoundError(name);
   }
-  for (const entry of fs9.readdirSync(paths.identitiesDir)) {
+  for (const entry of fs10.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      fs9.rmSync(path28.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      fs10.rmSync(path30.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity2(paths) === name) {
-    fs9.rmSync(paths.activeIdentityFile);
+    fs10.rmSync(paths.activeIdentityFile);
   }
 }
 
 // src/doctorReport.ts
 init_realPorts();
-import fs11 from "node:fs";
-import path29 from "node:path";
+import fs12 from "node:fs";
+import path31 from "node:path";
 init_signIn();
 init_identityAccounts();
 init_read();
 
 // src/codex/siwcStore.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/codex/auth.ts
-import { z as z24 } from "zod";
-var AuthFileSchema = z24.looseObject({
-  tokens: z24.looseObject({
-    access_token: z24.string().optional(),
-    refresh_token: z24.string().optional(),
-    id_token: z24.string().optional(),
-    account_id: z24.string().optional()
+import { z as z25 } from "zod";
+var AuthFileSchema = z25.looseObject({
+  tokens: z25.looseObject({
+    access_token: z25.string().optional(),
+    refresh_token: z25.string().optional(),
+    id_token: z25.string().optional(),
+    account_id: z25.string().optional()
   }).nullish(),
-  last_refresh: z24.string().optional()
+  last_refresh: z25.string().optional()
 });
-var TokenGrantSchema = z24.looseObject({
-  access_token: z24.string().min(1).optional(),
-  refresh_token: z24.string().min(1).optional(),
-  id_token: z24.string().min(1).optional(),
-  account_id: z24.string().min(1).optional()
+var TokenGrantSchema = z25.looseObject({
+  access_token: z25.string().min(1).optional(),
+  refresh_token: z25.string().min(1).optional(),
+  id_token: z25.string().min(1).optional(),
+  account_id: z25.string().min(1).optional()
 });
 var CodexAuthError = class extends Error {
   constructor(message) {
@@ -16841,41 +17305,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var SIWC_RESOURCE = "https://api.openai.com/v1";
 var SIWC_RESPONSES_URL = `${SIWC_RESOURCE}/responses`;
 var SIWC_PLAN_SCOPE = "chatgpt.tokens.use.direct";
-var TokenResponseSchema = z25.looseObject({
-  access_token: z25.string().min(1),
-  refresh_token: z25.string().min(1).optional(),
-  id_token: z25.string().min(1).optional(),
-  expires_in: z25.number().positive(),
-  scope: z25.string().optional()
+var TokenResponseSchema = z26.looseObject({
+  access_token: z26.string().min(1),
+  refresh_token: z26.string().min(1).optional(),
+  id_token: z26.string().min(1).optional(),
+  expires_in: z26.number().positive(),
+  scope: z26.string().optional()
 });
-var JwtHeaderSchema = z25.looseObject({ alg: z25.string(), kid: z25.string().optional() });
-var IdTokenClaimsSchema = z25.looseObject({
-  iss: z25.string(),
-  sub: z25.string().min(1),
-  aud: z25.union([z25.string(), z25.array(z25.string())]),
-  exp: z25.number(),
-  nonce: z25.string().optional(),
-  email: z25.string().optional()
+var JwtHeaderSchema = z26.looseObject({ alg: z26.string(), kid: z26.string().optional() });
+var IdTokenClaimsSchema = z26.looseObject({
+  iss: z26.string(),
+  sub: z26.string().min(1),
+  aud: z26.union([z26.string(), z26.array(z26.string())]),
+  exp: z26.number(),
+  nonce: z26.string().optional(),
+  email: z26.string().optional()
 });
-var JwksSchema = z25.object({ keys: z25.array(z25.looseObject({ kid: z25.string().optional(), kty: z25.string() })) });
+var JwksSchema = z26.object({ keys: z26.array(z26.looseObject({ kid: z26.string().optional(), kty: z26.string() })) });
 
 // src/codex/siwcStore.ts
-var SiwcGrantSchema = z26.strictObject({
-  clientId: z26.string().min(1),
-  sub: z26.string().min(1),
-  email: z26.string().optional(),
-  idToken: z26.string().min(1),
-  accessToken: z26.string().min(1),
-  refreshToken: z26.string().min(1),
-  scopes: z26.array(z26.string()).readonly(),
+var SiwcGrantSchema = z27.strictObject({
+  clientId: z27.string().min(1),
+  sub: z27.string().min(1),
+  email: z27.string().optional(),
+  idToken: z27.string().min(1),
+  accessToken: z27.string().min(1),
+  refreshToken: z27.string().min(1),
+  scopes: z27.array(z27.string()).readonly(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: z26.number()
+  expiresAt: z27.number()
 });
-var SiwcFileSchema = z26.strictObject({ registeredClientId: z26.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = z27.strictObject({ registeredClientId: z27.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -17132,7 +17596,7 @@ function pushFrontDoorListeners(push, readings) {
 
 // src/frontdoor/listenerReadings.ts
 init_probe();
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 function readFrontDoorListeners(state, supervisorAlive, probes) {
   if (!supervisorAlive) {
     return [];
@@ -17152,7 +17616,7 @@ function readFrontDoorListeners(state, supervisorAlive, probes) {
 }
 function realFrontDoorListenerProbes(paths) {
   return {
-    authenticateProvider: (port) => probeFrontDoorSync(port, fs10.readFileSync(paths.frontdoorCaCertFile, "utf8")),
+    authenticateProvider: (port) => probeFrontDoorSync(port, fs11.readFileSync(paths.frontdoorCaCertFile, "utf8")),
     connect: probeListenerAcceptSync,
     now: () => performance.now()
   };
@@ -17297,8 +17761,8 @@ function validateJson(schema, input) {
   let parsed;
   try {
     parsed = JSON.parse(input.raw);
-  } catch (error) {
-    return { ok: false, message: `${input.path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}` };
+  } catch {
+    return { ok: false, message: `${input.path} is not valid JSON.` };
   }
   const result = parseIgnoringUnrecognisedKeys(schema, parsed);
   if (!result.success) {
@@ -17317,7 +17781,7 @@ function tcpPortEraRecord(raw) {
   return (has("port") || has("lastPort")) && !has("socketPath");
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = path29.dirname(resolution.ownExecutablePath);
+  const ownDir = path31.dirname(resolution.ownExecutablePath);
   switch (resolution.agentShim.status) {
     case "ok":
       push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
@@ -17404,8 +17868,8 @@ function pushProvider(push, entry, cacheEnv, signIn) {
   let parsed;
   try {
     parsed = JSON.parse(entry.raw);
-  } catch (error) {
-    push("provider", "fail", `${entry.path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, entry.name);
+  } catch {
+    push("provider", "fail", `${entry.path} is not valid JSON.`, entry.name);
     return;
   }
   const conversion = legacyProviderConversion(parsed);
@@ -17437,14 +17901,14 @@ function pushProvider(push, entry, cacheEnv, signIn) {
 }
 function pushLegacyName(push, params) {
   const legacyVariables = Object.keys(params.env).filter((name) => name.startsWith(LEGACY_ENV_PREFIX) && params.env[name] !== void 0).sort();
-  if (legacyVariables.length === 0 && path29.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && path31.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
     push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
     return;
   }
   for (const name of legacyVariables) {
     push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
   }
-  if (path29.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (path31.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -17530,6 +17994,16 @@ function runDoctor(params) {
   }
   const validProfileNames = new Set(profileSources.keys());
   const validProviderNames = /* @__PURE__ */ new Set([...params.providers.map((entry) => entry.name), ...Object.keys(params.providerAliases ?? {})]);
+  const identityNames = new Set(params.identities.filter((entry) => entry.raw !== void 0).map((entry) => entry.name));
+  for (const journal of params.renameJournals?.journals ?? []) {
+    push("identity", "fail", `There is ${describeUnfinishedRename(journal, finishabilityOf(journal, (name) => identityNames.has(name)))}`, journal.from);
+  }
+  for (const { name, code } of params.unreachableIdentities ?? []) {
+    push("identity", "warn", `identities/${name} cannot be reached (${code}), so it is not counted as an identity. Repair the permissions of the directory or of what a symlink points through, or remove the entry.`, name);
+  }
+  for (const { file, detail } of params.renameJournals?.unreadable ?? []) {
+    push("identity", "fail", `${file} is not a rename journal this agent-shim can read (${detail}), so no identity can be renamed until it is fixed or removed, and it may be the trace of a rename that was left unfinished.`, path31.basename(file));
+  }
   const validIdentityNames = /* @__PURE__ */ new Set();
   const signedInAccounts = [];
   for (const entry of params.identities) {
@@ -17880,7 +18354,7 @@ function formatDoctorReport(report) {
 }
 function realpathOrSelf(target) {
   try {
-    return fs11.realpathSync(target);
+    return fs12.realpathSync(target);
   } catch {
     return target;
   }
@@ -17892,11 +18366,11 @@ function servingDoorListeners(paths) {
 }
 function collectDoctorReport(params) {
   const { paths } = params;
-  const identityNames = fs11.existsSync(paths.identitiesDir) ? fs11.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
+  const { names: identityNames, unreachable: unreachableIdentities } = listIdentityDirectories(paths);
   const identities = identityNames.map((name) => {
-    const farmRoot = path29.join(paths.identitiesDir, name);
-    const identityPath = path29.join(farmRoot, "identity.json");
-    return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot, credentialsFilePresent: fs11.existsSync(credentialsFilePath(farmRoot)), account: readIdentityAccount(realFsPort, paths.identitiesDir, name)?.account };
+    const farmRoot = path31.join(paths.identitiesDir, name);
+    const identityPath = path31.join(farmRoot, "identity.json");
+    return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot, credentialsFilePresent: fs12.existsSync(credentialsFilePath(farmRoot)), account: readIdentityAccount(realFsPort, paths.identitiesDir, name)?.account };
   });
   const usageSnapshots = {};
   for (const name of identityNames) {
@@ -17911,14 +18385,14 @@ function collectDoctorReport(params) {
       }
     }
   }
-  const profileNames = fs11.existsSync(paths.configProfilesDir) ? fs11.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+  const profileNames = fs12.existsSync(paths.configProfilesDir) ? fs12.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const configProfiles = profileNames.map((name) => {
-    const profilePath = path29.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = path31.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
-  const providerNames = fs11.existsSync(paths.providersDir) ? fs11.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+  const providerNames = fs12.existsSync(paths.providersDir) ? fs12.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const providers = providerNames.map((name) => {
-    const providerPath = path29.join(paths.providersDir, `${name}.json`);
+    const providerPath = path31.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -17930,12 +18404,12 @@ function collectDoctorReport(params) {
     binaryDiscovery = { ok: false, message: error instanceof Error ? error.message : String(error) };
   }
   const shimState = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const pathDirs = (params.env.PATH ?? "").split(path29.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(path31.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: path29.dirname(shimState.targetPath),
-      targetFilename: path29.basename(shimState.targetPath),
+      targetDir: path31.dirname(shimState.targetPath),
+      targetFilename: path31.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -17958,6 +18432,8 @@ function collectDoctorReport(params) {
     configProfiles,
     providers,
     providerAliases: readProviderAliases(paths),
+    renameJournals: listRenameJournals(realFarmFs, paths.identityRenamesDir),
+    unreachableIdentities,
     directoryRules: { path: paths.directoryRulesFile, raw: realFsPort.readFileUtf8(paths.directoryRulesFile) },
     globalConfig: { path: paths.globalConfigFile, raw: realFsPort.readFileUtf8(paths.globalConfigFile) },
     models: parsedModelsOf(paths),
@@ -17965,14 +18441,14 @@ function collectDoctorReport(params) {
     categoriesLocal: { path: paths.categoriesLocalFile, raw: realFsPort.readFileUtf8(paths.categoriesLocalFile) },
     activeIdentity: { path: paths.activeIdentityFile, raw: realFsPort.readFileUtf8(paths.activeIdentityFile) },
     binaryDiscovery,
-    claudeShim: { state: shimState, targetExists: shimState !== void 0 && fs11.existsSync(shimState.targetPath) },
+    claudeShim: { state: shimState, targetExists: shimState !== void 0 && fs12.existsSync(shimState.targetPath) },
     rootPath: paths.root,
     pathResolution: {
       ownExecutablePath,
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: path29.dirname(ownExecutablePath),
+          targetDir: path31.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -18013,92 +18489,92 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-var UsageListOutputSchema = z29.strictObject({ snapshots: z29.readonly(z29.array(UsageSnapshotSchema)) });
-var UsageWindowsInputSchema = z29.strictObject({
-  identity: z29.string().min(1),
-  provider: z29.string().min(1).optional()
+var UsageListOutputSchema = z30.strictObject({ snapshots: z30.readonly(z30.array(UsageSnapshotSchema)) });
+var UsageWindowsInputSchema = z30.strictObject({
+  identity: z30.string().min(1),
+  provider: z30.string().min(1).optional()
 });
-var EffectiveWindowSchema = z29.strictObject({
+var EffectiveWindowSchema = z30.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: z29.boolean(),
+  reset: z30.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: z29.number().optional(),
+  utilization: z30.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: z29.number().optional(),
+  resetsAtMs: z30.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: z29.string().optional()
+  status: z30.string().optional()
 });
-var UsageWindowsOutputSchema = z29.strictObject({
-  identity: z29.string(),
-  provider: z29.string(),
+var UsageWindowsOutputSchema = z30.strictObject({
+  identity: z30.string(),
+  provider: z30.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: z29.iso.datetime().optional(),
+  observedAt: z30.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = z29.strictObject({
+var UsageLiveOutputSchema = z30.strictObject({
   /** The freshest observation the door holds, never narrowed by the read's session filter because it is the door's single latest statement of the account's quota; absent while no rate_limit_event has been filed at all. */
   latest: RcLiveRateLimitSchema.optional(),
   /** One observation per session whose stream has filed a rate_limit_event this door generation. */
-  sessions: z29.readonly(z29.array(RcLiveRateLimitSchema))
+  sessions: z30.readonly(z30.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = z29.strictObject({
-  pid: z29.int().positive(),
-  startedAt: z29.number(),
-  alive: z29.boolean()
+var FrontDoorSessionStatusSchema = z30.strictObject({
+  pid: z30.int().positive(),
+  startedAt: z30.number(),
+  alive: z30.boolean()
 });
-var HeadroomSocketTargetSchema = z29.union([z29.strictObject({ socketPath: z29.string() }), z29.strictObject({ refused: z29.string() })]);
-var FrontDoorStatusOutputSchema = z29.strictObject({
+var HeadroomSocketTargetSchema = z30.union([z30.strictObject({ socketPath: z30.string() }), z30.strictObject({ refused: z30.string() })]);
+var FrontDoorStatusOutputSchema = z30.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: z29.boolean(),
+  supervisorAlive: z30.boolean(),
   /** The pids of earlier doors that released their addresses and are finishing the connections they carried: running, but not serving anything new. */
-  draining: z29.readonly(z29.array(z29.number().int().positive())),
-  sessions: z29.readonly(z29.array(FrontDoorSessionStatusSchema)),
+  draining: z30.readonly(z30.array(z30.number().int().positive())),
+  sessions: z30.readonly(z30.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: z29.string(),
-  logExists: z29.boolean()
+  logPath: z30.string(),
+  logExists: z30.boolean()
 });
-var FrontDoorSessionsOutputSchema = z29.strictObject({ sessions: z29.readonly(z29.array(FrontDoorSessionStatusSchema)) });
-var CheckRunInputSchema = z29.strictObject({
-  path: z29.string().min(1),
-  identity: z29.string().min(1).optional()
-}).refine((input) => path30.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var PoolPickInputSchema = z29.strictObject({
-  pool: z29.string().min(1),
-  path: z29.string().min(1)
-}).refine((input) => path30.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var DoctorFindingSchema = z29.strictObject({
-  section: z29.enum(DOCTOR_SECTIONS),
-  subject: z29.string().optional(),
-  severity: z29.enum(DOCTOR_SEVERITIES),
-  message: z29.string()
+var FrontDoorSessionsOutputSchema = z30.strictObject({ sessions: z30.readonly(z30.array(FrontDoorSessionStatusSchema)) });
+var CheckRunInputSchema = z30.strictObject({
+  path: z30.string().min(1),
+  identity: z30.string().min(1).optional()
+}).refine((input) => path32.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = z30.strictObject({
+  pool: z30.string().min(1),
+  path: z30.string().min(1)
+}).refine((input) => path32.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var DoctorFindingSchema = z30.strictObject({
+  section: z30.enum(DOCTOR_SECTIONS),
+  subject: z30.string().optional(),
+  severity: z30.enum(DOCTOR_SEVERITIES),
+  message: z30.string()
 });
-var DoctorRunOutputSchema = z29.strictObject({
+var DoctorRunOutputSchema = z30.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: z29.boolean(),
-  findings: z29.readonly(z29.array(DoctorFindingSchema))
+  ok: z30.boolean(),
+  findings: z30.readonly(z30.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = z29.strictObject({
-  action: z29.literal("restarting"),
-  previousPid: z29.int().positive()
+var FrontDoorRestartOutputSchema = z30.strictObject({
+  action: z30.literal("restarting"),
+  previousPid: z30.int().positive()
 });
-var UpdateCheckOutputSchema = z29.strictObject({
-  current: z29.string(),
-  latest: z29.string(),
-  action: z29.enum(["current", "available", "updated"])
+var UpdateCheckOutputSchema = z30.strictObject({
+  current: z30.string(),
+  latest: z30.string(),
+  action: z30.enum(["current", "available", "updated"])
 });
-var CodexSignInSchema = z29.discriminatedUnion("state", [
-  z29.strictObject({ state: z29.literal("none") }),
-  z29.strictObject({ state: z29.literal("signed-in"), email: z29.string().optional(), planScope: z29.boolean(), accessTokenExpiresAt: z29.number() }),
-  z29.strictObject({ state: z29.literal("unreadable"), message: z29.string() })
+var CodexSignInSchema = z30.discriminatedUnion("state", [
+  z30.strictObject({ state: z30.literal("none") }),
+  z30.strictObject({ state: z30.literal("signed-in"), email: z30.string().optional(), planScope: z30.boolean(), accessTokenExpiresAt: z30.number() }),
+  z30.strictObject({ state: z30.literal("unreadable"), message: z30.string() })
 ]);
-var CodexStatusOutputSchema = z29.strictObject({
+var CodexStatusOutputSchema = z30.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: z29.readonly(z29.array(z29.string()))
+  codexProviders: z30.readonly(z30.array(z30.string()))
 });
-var CodexLogoutOutputSchema = z29.strictObject({
-  hadGrant: z29.boolean(),
-  revoked: z29.boolean()
+var CodexLogoutOutputSchema = z30.strictObject({
+  hadGrant: z30.boolean(),
+  revoked: z30.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -18253,72 +18729,74 @@ function requireRuleSelector(paths, selector) {
 
 // src/frontdoor/configApi.ts
 init_identity();
+init_replayRun();
 init_providersStore();
 
 // src/frontdoor/configSchemas.ts
 init_schema();
 init_names();
+import { z as z31 } from "zod";
 init_statusline();
-import { z as z30 } from "zod";
-var RemovalConfirmationSchema = z30.boolean();
-var CredentialWriteSchema = (targets) => z30.strictObject({
-  sources: z30.array(RemoteCredentialSourceSchema).min(1).optional(),
-  target: z30.enum(targets).optional(),
-  cache: z30.union([z30.literal(false), CredentialCacheSchema]).optional()
+var RemovalConfirmationSchema = z31.boolean();
+var CredentialWriteSchema = (targets) => z31.strictObject({
+  sources: z31.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: z31.enum(targets).optional(),
+  cache: z31.union([z31.literal(false), CredentialCacheSchema]).optional()
 });
-var CredentialSummarySchema2 = z30.strictObject({
-  target: z30.enum(CREDENTIAL_TARGETS),
-  sources: z30.readonly(z30.array(
-    z30.discriminatedUnion("kind", [
-      z30.strictObject({ kind: z30.literal("env"), variable: z30.string() }),
-      z30.strictObject({ kind: z30.literal("file"), path: z30.string() }),
-      z30.strictObject({ kind: z30.literal("command"), program: z30.string() }),
-      z30.strictObject({ kind: z30.literal("op"), reference: z30.string() }),
-      z30.strictObject({ kind: z30.literal("keychain"), service: z30.string(), account: z30.string().optional() }),
-      z30.strictObject({ kind: z30.literal("literal") })
+var CredentialSummarySchema2 = z31.strictObject({
+  target: z31.enum(CREDENTIAL_TARGETS),
+  sources: z31.readonly(z31.array(
+    z31.discriminatedUnion("kind", [
+      z31.strictObject({ kind: z31.literal("env"), variable: z31.string() }),
+      z31.strictObject({ kind: z31.literal("file"), path: z31.string() }),
+      z31.strictObject({ kind: z31.literal("command"), program: z31.string() }),
+      z31.strictObject({ kind: z31.literal("op"), reference: z31.string() }),
+      z31.strictObject({ kind: z31.literal("keychain"), service: z31.string(), account: z31.string().optional() }),
+      z31.strictObject({ kind: z31.literal("literal") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-var mutationOutput = (kind, action) => z30.strictObject({ action: z30.literal(action), kind: z30.literal(kind), name: z30.string() });
-var storedMutationOutput = (kind, action, value) => z30.strictObject({ action: z30.literal(action), kind: z30.literal(kind), name: z30.string(), value });
-var IdentityValueSchema = z30.strictObject({
-  name: z30.string(),
-  label: z30.string().optional(),
-  defaultConfigProfile: z30.string().optional(),
-  provider: z30.string().optional(),
-  allowAmbientCredential: z30.boolean(),
+var mutationOutput = (kind, action) => z31.strictObject({ action: z31.literal(action), kind: z31.literal(kind), name: z31.string() });
+var storedMutationOutput = (kind, action, value) => z31.strictObject({ action: z31.literal(action), kind: z31.literal(kind), name: z31.string(), value });
+var IdentityValueSchema = z31.strictObject({
+  name: z31.string(),
+  label: z31.string().optional(),
+  defaultConfigProfile: z31.string().optional(),
+  provider: z31.string().optional(),
+  allowAmbientCredential: z31.boolean(),
   credential: CredentialSummarySchema2.optional(),
-  anchors: z30.array(AnchorSchema).optional()
+  anchors: z31.array(AnchorSchema).optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-var ProviderValueSchema = z30.strictObject({
-  name: z30.string(),
-  kind: z30.enum(PROVIDER_KINDS),
-  displayName: z30.string(),
-  baseUrl: z30.string().optional(),
+var ProviderValueSchema = z31.strictObject({
+  name: z31.string(),
+  kind: z31.enum(PROVIDER_KINDS),
+  displayName: z31.string(),
+  baseUrl: z31.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2.optional(),
-  env: z30.record(z30.string(), z30.string()).optional()
+  env: z31.record(z31.string(), z31.string()).optional()
 });
-var ConfigNameInputSchema = z30.strictObject({ name: z30.string().min(1) });
+var ConfigNameInputSchema = z31.strictObject({ name: z31.string().min(1) });
+var ConfigIdentityAddInputSchema = z31.strictObject({ name: z31.string().min(1), keepKeychainLogin: z31.boolean().optional().describe(KEEP_KEYCHAIN_LOGIN_DESCRIPTION) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-var ConfigIdentitySetInputSchema = z30.strictObject({
-  name: z30.string().min(1),
+var ConfigIdentitySetInputSchema = z31.strictObject({
+  name: z31.string().min(1),
   /** The identity's display label; `false` clears it. */
-  label: z30.union([IdentityLabelSchema, z30.literal(false)]).optional(),
-  defaultConfigProfile: z30.union([z30.string().min(1), z30.literal(false)]).optional(),
+  label: z31.union([IdentityLabelSchema, z31.literal(false)]).optional(),
+  defaultConfigProfile: z31.union([z31.string().min(1), z31.literal(false)]).optional(),
   /** The provider the identity exists for; `false` clears it. */
-  provider: z30.union([z30.string().min(1), z30.literal(false)]).optional(),
-  allowAmbientCredential: z30.boolean().optional(),
-  credential: z30.union([z30.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
+  provider: z31.union([z31.string().min(1), z31.literal(false)]).optional(),
+  allowAmbientCredential: z31.boolean().optional(),
+  credential: z31.union([z31.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
   /** `false` removes the anchors; a list replaces them. */
-  anchors: z30.union([z30.literal(false), z30.array(AnchorSchema).min(1)]).optional()
+  anchors: z31.union([z31.literal(false), z31.array(AnchorSchema).min(1)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = z30.strictObject({ name: z30.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = z31.strictObject({ name: z31.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
-var ConfigStatuslineSetSchema = z30.record(z30.string(), z30.unknown()).superRefine((settings, context) => {
+var ConfigStatuslineSetSchema = z31.record(z31.string(), z31.unknown()).superRefine((settings, context) => {
   for (const key of Object.keys(settings)) {
     if (key === STATUSLINE_EXTRA_GROUP || key.startsWith(`${STATUSLINE_EXTRA_GROUP}.`)) {
       context.addIssue({ code: "custom", path: [key], message: `a config write through the API cannot set "${key}": the extra segment's command runs a program, so only your own configuration (the global config, a profile you edit yourself, a directory rule or a command-line assignment) may set it` });
@@ -18326,102 +18804,105 @@ var ConfigStatuslineSetSchema = z30.record(z30.string(), z30.unknown()).superRef
   }
 });
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-var ConfigProfileAddInputSchema = z30.strictObject({
-  name: z30.string().min(1),
-  extends: z30.array(z30.string().min(1)).optional(),
-  description: z30.string().optional()
+var ConfigProfileAddInputSchema = z31.strictObject({
+  name: z31.string().min(1),
+  extends: z31.array(z31.string().min(1)).optional(),
+  description: z31.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-var ConfigProfileSetInputSchema = z30.strictObject({
-  name: z30.string().min(1),
-  category: z30.record(z30.string(), z30.boolean()).optional(),
-  entry: z30.record(z30.string(), z30.boolean()).optional(),
-  extends: z30.union([z30.array(z30.string().min(1)), z30.literal(false)]).optional(),
-  description: z30.union([z30.string(), z30.literal(false)]).optional(),
-  launch: z30.strictObject({
-    skipPermissions: z30.boolean().optional(),
-    remoteControl: z30.boolean().optional(),
-    headroom: z30.boolean().optional(),
-    trackUsage: z30.boolean().optional(),
-    provider: z30.union([z30.string().min(1), z30.literal(false)]).optional(),
-    claudeVersion: z30.union([z30.string().min(1), z30.literal(false)]).optional(),
-    delay: z30.union([z30.string().regex(DURATION_RE), z30.literal(false)]).optional(),
-    pause: z30.boolean().optional(),
-    explain: z30.boolean().optional(),
-    proxyBypass: z30.union([z30.array(z30.string().min(1)), z30.literal(false)]).optional(),
-    statusline: z30.strictObject({
+var ConfigProfileSetInputSchema = z31.strictObject({
+  name: z31.string().min(1),
+  category: z31.record(z31.string(), z31.boolean()).optional(),
+  entry: z31.record(z31.string(), z31.boolean()).optional(),
+  extends: z31.union([z31.array(z31.string().min(1)), z31.literal(false)]).optional(),
+  description: z31.union([z31.string(), z31.literal(false)]).optional(),
+  launch: z31.strictObject({
+    skipPermissions: z31.boolean().optional(),
+    remoteControl: z31.boolean().optional(),
+    headroom: z31.boolean().optional(),
+    trackUsage: z31.boolean().optional(),
+    provider: z31.union([z31.string().min(1), z31.literal(false)]).optional(),
+    claudeVersion: z31.union([z31.string().min(1), z31.literal(false)]).optional(),
+    delay: z31.union([z31.string().regex(DURATION_RE), z31.literal(false)]).optional(),
+    pause: z31.boolean().optional(),
+    explain: z31.boolean().optional(),
+    proxyBypass: z31.union([z31.array(z31.string().min(1)), z31.literal(false)]).optional(),
+    statusline: z31.strictObject({
       set: ConfigStatuslineSetSchema.optional(),
-      unset: z30.array(z30.string()).optional()
+      unset: z31.array(z31.string()).optional()
     }).optional()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = z30.strictObject({ name: z30.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = z31.strictObject({ name: z31.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-var PoolMembersInputSchema = z30.array(z30.string().min(1)).min(1);
-var ConfigPoolAddInputSchema = z30.strictObject({
-  name: z30.string().min(1),
+var PoolMembersInputSchema = z31.array(z31.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = z31.strictObject({
+  name: z31.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: z30.enum(POOL_PREFERENCES).optional(),
-  resumeOnLimit: z30.boolean().optional(),
-  compactBeforeLimit: z30.boolean().optional(),
+  preference: z31.enum(POOL_PREFERENCES).optional(),
+  resumeOnLimit: z31.boolean().optional(),
+  compactBeforeLimit: z31.boolean().optional(),
   compactAtUtilisation: CompactAtUtilisationSchema.optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = z30.strictObject({
-  name: z30.string().min(1),
+var ConfigPoolSetInputSchema = z31.strictObject({
+  name: z31.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: z30.union([z30.enum(POOL_PREFERENCES), z30.literal(false)]).optional(),
-  resumeOnLimit: z30.boolean().optional(),
-  compactBeforeLimit: z30.boolean().optional(),
-  compactAtUtilisation: z30.union([CompactAtUtilisationSchema, z30.literal(false)]).optional()
+  preference: z31.union([z31.enum(POOL_PREFERENCES), z31.literal(false)]).optional(),
+  resumeOnLimit: z31.boolean().optional(),
+  compactBeforeLimit: z31.boolean().optional(),
+  compactAtUtilisation: z31.union([CompactAtUtilisationSchema, z31.literal(false)]).optional()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = z30.strictObject({ name: z30.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = z31.strictObject({ name: z31.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-var ConfigProviderAddInputSchema = z30.strictObject({
-  name: z30.string().min(1),
-  kind: z30.enum(PROVIDER_KINDS).optional(),
-  displayName: z30.string().min(1),
-  baseUrl: z30.string().min(1).optional(),
+var ConfigProviderAddInputSchema = z31.strictObject({
+  name: z31.string().min(1),
+  kind: z31.enum(PROVIDER_KINDS).optional(),
+  displayName: z31.string().min(1),
+  baseUrl: z31.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).required({ sources: true }),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderAddOutputSchema = storedMutationOutput("provider", "created", ProviderValueSchema);
-var ConfigProviderSetInputSchema = z30.strictObject({
-  name: z30.string().min(1),
-  displayName: z30.string().min(1).optional(),
-  baseUrl: z30.string().min(1).optional(),
+var ConfigProviderSetInputSchema = z31.strictObject({
+  name: z31.string().min(1),
+  displayName: z31.string().min(1).optional(),
+  baseUrl: z31.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = z30.strictObject({ name: z30.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = z31.strictObject({ name: z31.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-var ConfigRuleAddInputSchema = z30.strictObject({
-  path: z30.string().min(1),
-  configProfile: z30.string().min(1).optional(),
-  identity: z30.string().min(1).optional()
+var ConfigRuleAddInputSchema = z31.strictObject({
+  path: z31.string().min(1),
+  configProfile: z31.string().min(1).optional(),
+  identity: z31.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-var ConfigRuleSetInputSchema = z30.strictObject({
-  path: z30.string().min(1),
-  configProfile: z30.union([z30.string().min(1), z30.literal(false)]).optional(),
-  identity: z30.union([z30.string().min(1), z30.literal(false)]).optional()
+var ConfigRuleSetInputSchema = z31.strictObject({
+  path: z31.string().min(1),
+  configProfile: z31.union([z31.string().min(1), z31.literal(false)]).optional(),
+  identity: z31.union([z31.string().min(1), z31.literal(false)]).optional()
 });
 var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = z30.strictObject({ path: z30.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = z31.strictObject({ path: z31.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
 var CONFIG_API_TAG = "config";
 function refusal(error) {
+  if (error instanceof KeychainLookupError) {
+    throw new ORPCError2("SERVICE_UNAVAILABLE", { message: error.message });
+  }
   if (error instanceof IdentityNotFoundError || error instanceof ProfileNotFoundError || error instanceof PoolNotFoundError || error instanceof ProviderNotFoundError || error instanceof DirectoryRuleNotFoundError) {
     throw new ORPCError2("NOT_FOUND", { message: error.message });
   }
-  if (error instanceof IdentityAlreadyExistsError || error instanceof ProfileAlreadyExistsError || error instanceof PoolAlreadyExistsError || error instanceof ProviderAlreadyExistsError || error instanceof DirectoryRuleAlreadyExistsError) {
+  if (error instanceof IdentityAlreadyExistsError || error instanceof ProfileAlreadyExistsError || error instanceof PoolAlreadyExistsError || error instanceof ProviderAlreadyExistsError || error instanceof DirectoryRuleAlreadyExistsError || error instanceof KeychainLoginError) {
     throw new ORPCError2("CONFLICT", { message: error.message });
   }
   if (error instanceof CliError) {
@@ -18429,6 +18910,13 @@ function refusal(error) {
   }
   throw error;
 }
+async function guardedAsync(write) {
+  try {
+    await write();
+  } catch (error) {
+    refusal(error);
+  }
+}
 function guarded(write) {
   try {
     return write();
@@ -18478,16 +18966,21 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path42, summary) => authed.meta(openapi3({ method: "POST", path: path42, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path45, summary) => authed.meta(openapi3({ method: "POST", path: path45, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
-        add: route("/rest/config/identity/add", "Create an identity").input(ConfigNameInputSchema).output(ConfigIdentityAddOutputSchema).handler(
-          ({ input }) => guarded(() => {
+        add: route("/rest/config/identity/add", "Create an identity").input(ConfigIdentityAddInputSchema).output(ConfigIdentityAddOutputSchema).handler(async ({ input }) => {
+          await guardedAsync(async () => {
+            await resolveWithAsyncRuns((run) => {
+              requireIdentityAddable(paths, input.name, { run, platform: deps.keychain.platform }, input.keepKeychainLogin === true);
+            }, deps.keychain.runAsync);
+          });
+          return guarded(() => {
             addIdentity(paths, input.name);
             return { action: "created", kind: "identity", name: input.name, value: identityValue(input.name, paths) };
-          })
-        ),
+          });
+        }),
         set: route("/rest/config/identity/set", "Update an identity's label, default profile, provider, ambient-credential setting, credential or anchors").input(ConfigIdentitySetInputSchema).output(ConfigIdentitySetOutputSchema).handler(
           ({ input }) => guarded(() => {
             requireChange(input.label !== void 0 || input.defaultConfigProfile !== void 0 || input.provider !== void 0 || input.allowAmbientCredential !== void 0 || input.credential !== void 0 || input.anchors !== void 0, "label, defaultConfigProfile, provider, allowAmbientCredential, credential or anchors");
@@ -18736,43 +19229,43 @@ import { openapi as openapi4 } from "@orpc/openapi";
 import { eventIterator as eventIterator2, withEventMeta as withEventMeta2 } from "@orpc/server";
 
 // src/frontdoor/eventSchemas.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var DOOR_EVENT_SOURCE_RC = "rc";
 var LAUNCH_EVENT_SOURCE = "launch";
 var USAGE_EVENT_SOURCE = "usage";
 var DOOR_HEALTH_EVENT_SOURCE = "door";
 var QUOTA_EXPIRING_EVENT_SOURCE = "quota-expiring";
-var DoorEventSchema = z31.strictObject({
-  source: z31.string().min(1),
+var DoorEventSchema = z32.strictObject({
+  source: z32.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: z31.number().int().positive(),
-  payload: z31.unknown()
+  sequence: z32.number().int().positive(),
+  payload: z32.unknown()
 });
-var DoorEventSourceQuerySchema = z31.strictObject({
-  sources: z31.array(z31.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = z32.strictObject({
+  sources: z32.array(z32.string().min(1)).min(1).optional()
 });
-var LaunchLifecycleEventSchema = z31.strictObject({
-  kind: z31.enum(["registered", "pruned", "ended"]),
-  pid: z31.number().int().positive(),
-  startedAt: z31.number(),
-  observedAt: z31.number()
+var LaunchLifecycleEventSchema = z32.strictObject({
+  kind: z32.enum(["registered", "pruned", "ended"]),
+  pid: z32.number().int().positive(),
+  startedAt: z32.number(),
+  observedAt: z32.number()
 });
-var DoorHealthEventSchema = z31.discriminatedUnion("kind", [
-  z31.strictObject({ kind: z31.literal("generation"), pid: z31.number().int().positive(), providerPort: z31.number().int().positive(), connectPort: z31.number().int().positive(), directPort: z31.number().int().positive(), observedAt: z31.number() }),
-  z31.strictObject({ kind: z31.literal("listenerFailed"), pid: z31.number().int().positive(), listener: z31.enum(["provider", "connect", "direct"]), message: z31.string(), observedAt: z31.number() }),
-  z31.strictObject({ kind: z31.literal("binaryTurnover"), pid: z31.number().int().positive(), observedAt: z31.number() }),
-  z31.strictObject({ kind: z31.literal("idleShutdown"), pid: z31.number().int().positive(), observedAt: z31.number() }),
-  z31.strictObject({ kind: z31.literal("superseded"), pid: z31.number().int().positive(), ownerPid: z31.number().int().positive(), observedAt: z31.number() }),
-  z31.strictObject({ kind: z31.literal("drained"), pid: z31.number().int().positive(), observedAt: z31.number() })
+var DoorHealthEventSchema = z32.discriminatedUnion("kind", [
+  z32.strictObject({ kind: z32.literal("generation"), pid: z32.number().int().positive(), providerPort: z32.number().int().positive(), connectPort: z32.number().int().positive(), directPort: z32.number().int().positive(), observedAt: z32.number() }),
+  z32.strictObject({ kind: z32.literal("listenerFailed"), pid: z32.number().int().positive(), listener: z32.enum(["provider", "connect", "direct"]), message: z32.string(), observedAt: z32.number() }),
+  z32.strictObject({ kind: z32.literal("binaryTurnover"), pid: z32.number().int().positive(), observedAt: z32.number() }),
+  z32.strictObject({ kind: z32.literal("idleShutdown"), pid: z32.number().int().positive(), observedAt: z32.number() }),
+  z32.strictObject({ kind: z32.literal("superseded"), pid: z32.number().int().positive(), ownerPid: z32.number().int().positive(), observedAt: z32.number() }),
+  z32.strictObject({ kind: z32.literal("drained"), pid: z32.number().int().positive(), observedAt: z32.number() })
 ]);
-var QuotaExpiringEventSchema = z31.strictObject({
-  identity: z31.string().min(1),
-  provider: z31.string().min(1),
-  window: z31.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = z32.strictObject({
+  identity: z32.string().min(1),
+  provider: z32.string().min(1),
+  window: z32.enum(["fiveHour", "sevenDay"]),
   /** The fraction of the window already used when it was seen expiring, always below one because a fully used window has nothing left to spend. */
-  utilization: z31.number().min(0).max(1),
-  resetsAt: z31.iso.datetime(),
-  observedAt: z31.number()
+  utilization: z32.number().min(0).max(1),
+  resetsAt: z32.iso.datetime(),
+  observedAt: z32.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -18855,61 +19348,61 @@ import { ORPCError as ORPCError5 } from "@orpc/client";
 import { openapi as openapi6 } from "@orpc/openapi";
 
 // src/frontdoor/launchSchemas.ts
-import path31 from "node:path";
-import { z as z32 } from "zod";
+import path33 from "node:path";
+import { z as z33 } from "zod";
 init_statusline();
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = z32.strictObject({
-  path: z32.string().min(1),
+var LaunchResolveInputSchema = z33.strictObject({
+  path: z33.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: z32.readonly(z32.array(z32.string())).optional(),
+  argv: z33.readonly(z33.array(z33.string())).optional(),
   /** The launch's inherited environment. Absent means an empty one: the door's own environment is never a substitute for the caller's, so a caller that wants `AGENT_SHIM_*` switches or a `CLAUDE_CONFIG_DIR` considered names them here. Values are read, never reported. */
-  env: z32.record(z32.string(), z32.string()).optional()
-}).refine((input) => path31.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var LaunchPoolDecisionSchema = z32.strictObject({
-  name: z32.string(),
-  reasons: z32.readonly(z32.array(z32.string())),
-  movedOff: z32.strictObject({ identity: z32.string(), reason: z32.string() }).optional()
+  env: z33.record(z33.string(), z33.string()).optional()
+}).refine((input) => path33.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var LaunchPoolDecisionSchema = z33.strictObject({
+  name: z33.string(),
+  reasons: z33.readonly(z33.array(z33.string())),
+  movedOff: z33.strictObject({ identity: z33.string(), reason: z33.string() }).optional()
 });
-var LaunchDecisionSchema = z32.strictObject({
-  identity: z32.string().optional(),
-  identitySource: z32.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = z33.strictObject({
+  identity: z33.string().optional(),
+  identitySource: z33.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: z32.boolean(),
-  configDir: z32.string().optional(),
-  configProfile: z32.string().optional(),
-  configProfileSource: z32.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: z32.string().optional()
+  configDirEscapeHatch: z33.boolean(),
+  configDir: z33.string().optional(),
+  configProfile: z33.string().optional(),
+  configProfileSource: z33.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: z33.string().optional()
 });
-var LaunchFlagsSchema = z32.strictObject({
-  skipPermissions: z32.boolean(),
-  remoteControl: z32.boolean(),
-  headroom: z32.boolean(),
-  trackUsage: z32.boolean(),
-  pause: z32.boolean(),
-  explain: z32.boolean(),
+var LaunchFlagsSchema = z33.strictObject({
+  skipPermissions: z33.boolean(),
+  remoteControl: z33.boolean(),
+  headroom: z33.boolean(),
+  trackUsage: z33.boolean(),
+  pause: z33.boolean(),
+  explain: z33.boolean(),
   /** How long the launch waits after its own output before it starts claude, in milliseconds. */
-  delayMs: z32.number(),
+  delayMs: z33.number(),
   /** The hosts the launch keeps off the front door by adding them to the child's `NO_PROXY`. */
-  proxyBypass: z32.array(z32.string()).readonly(),
+  proxyBypass: z33.array(z33.string()).readonly(),
   /** How the session's built-in statusline looks, when the launch configures any of it. */
   statusline: StatuslineSchema.optional()
 });
-var LaunchResolveOutputSchema = z32.strictObject({
+var LaunchResolveOutputSchema = z33.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: z32.strictObject({ version: z32.string(), source: z32.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: z33.strictObject({ version: z33.string(), source: z33.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: z32.string(),
+  bin: z33.string(),
   /** The arguments the launch would pass it: the tool's own flags, then `CLAUDE_EXTRA_FLAGS`, then the caller's own. */
-  args: z32.readonly(z32.array(z32.string())),
+  args: z33.readonly(z33.array(z33.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: z32.strictObject({ subject: z32.enum(["provider", "identity"]), name: z32.string(), summary: CredentialSummarySchema }).optional(),
-  routing: z32.strictObject({ frontDoor: z32.boolean(), headroom: z32.boolean() }),
+  credential: z33.strictObject({ subject: z33.enum(["provider", "identity"]), name: z33.string(), summary: CredentialSummarySchema }).optional(),
+  routing: z33.strictObject({ frontDoor: z33.boolean(), headroom: z33.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: z32.readonly(z32.array(z32.string())),
-  warnings: z32.readonly(z32.array(z32.string()))
+  environment: z33.readonly(z33.array(z33.string())),
+  warnings: z33.readonly(z33.array(z33.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -18945,22 +19438,22 @@ function createLaunchApiRouter(deps) {
 // src/frontdoor/agentTreesApi.ts
 import { ORPCError as ORPCError6 } from "@orpc/client";
 import { openapi as openapi7 } from "@orpc/openapi";
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 init_cliError();
-var AgentTreesListInputSchema = z33.strictObject({
+var AgentTreesListInputSchema = z34.strictObject({
   /** Only this identity's sessions. */
-  identity: z33.string().optional(),
+  identity: z34.string().optional(),
   /** Include sessions that spawned no agent and ran no workflow. */
-  all: z33.boolean().optional()
+  all: z34.boolean().optional()
 });
-var AgentTreesListOutputSchema = z33.array(SessionSummarySchema);
-var AgentTreesShowInputSchema = z33.strictObject({
+var AgentTreesListOutputSchema = z34.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = z34.strictObject({
   /** A session id, or an unambiguous prefix of one. */
-  session: z33.string().min(1),
+  session: z34.string().min(1),
   /** Look only in this identity. */
-  identity: z33.string().optional()
+  identity: z34.string().optional()
 });
-var AgentTreesShowOutputSchema = z33.strictObject({ identities: z33.array(z33.string()), ...MergedAgentTreeSchema.shape });
+var AgentTreesShowOutputSchema = z34.strictObject({ identities: z34.array(z34.string()), ...MergedAgentTreeSchema.shape });
 function asBadRequest(error) {
   if (error instanceof CliError) {
     throw new ORPCError6("BAD_REQUEST", { message: error.message });
@@ -21047,7 +21540,7 @@ data: ${JSON.stringify(envelope)}
 
 // src/frontdoor/rcSelfHostMint.ts
 init_account();
-import path32 from "node:path";
+import path34 from "node:path";
 var CREDENTIALS_FILE2 = ".credentials.json";
 var CLAUDE_JSON2 = ".claude.json";
 var RC_SELF_HOST_RECORD_DIR = "rc-selfhost";
@@ -21057,8 +21550,8 @@ var SELF_HOST_SUBSCRIPTION_TYPE = "max";
 function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readJsonObject(fs14, file) {
-  const raw = fs14.readFileUtf8(file);
+function readJsonObject(fs15, file) {
+  const raw = fs15.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -21070,8 +21563,8 @@ function readJsonObject(fs14, file) {
   }
   return isRecord14(parsed) ? parsed : void 0;
 }
-function readRcSelfHostRecord(fs14, frontdoorDir) {
-  const parsed = readJsonObject(fs14, path32.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+function readRcSelfHostRecord(fs15, frontdoorDir) {
+  const parsed = readJsonObject(fs15, path34.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
   if (parsed === void 0) {
     return void 0;
   }
@@ -21085,11 +21578,11 @@ function mintRcSelfHostCredential(deps) {
   if (!isIdentityName(deps.identity)) {
     throw new Error(`"${deps.identity}" is not a valid identity name.`);
   }
-  const identityDir = path32.join(deps.identitiesDir, deps.identity);
-  const credentialsFile = path32.join(identityDir, CREDENTIALS_FILE2);
-  const claudeJsonFile = path32.join(identityDir, CLAUDE_JSON2);
-  const recordDir = path32.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
-  const recordFile = path32.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const identityDir = path34.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = path34.join(identityDir, CREDENTIALS_FILE2);
+  const claudeJsonFile = path34.join(identityDir, CLAUDE_JSON2);
+  const recordDir = path34.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile2 = path34.join(recordDir, RC_SELF_HOST_RECORD_FILE);
   const previousRecord = readRcSelfHostRecord(deps.fs, deps.frontdoorDir);
   const existingCredentials = readJsonObject(deps.fs, credentialsFile);
   const existingOauth = isRecord14(existingCredentials?.claudeAiOauth) ? existingCredentials.claudeAiOauth : void 0;
@@ -21105,7 +21598,7 @@ function mintRcSelfHostCredential(deps) {
   const organizationUuid = deps.newUuid();
   const accountUuid = deps.newUuid();
   const mintedAt = new Date(deps.now()).toISOString();
-  deps.fs.mkdirPrivate(path32.dirname(credentialsFile));
+  deps.fs.mkdirPrivate(path34.dirname(credentialsFile));
   deps.fs.writeFilePrivate(credentialsFile, `${JSON.stringify({ ...existingCredentials, claudeAiOauth: { accessToken, refreshToken, expiresAt: null, scopes: [...RC_SELF_HOST_SCOPE_LIST], subscriptionType: SELF_HOST_SUBSCRIPTION_TYPE, rateLimitTier: null } }, null, 2)}
 `);
   const claudeJson = readJsonObject(deps.fs, claudeJsonFile) ?? {};
@@ -21132,9 +21625,9 @@ function mintRcSelfHostCredential(deps) {
   }, null, 2)}
 `);
   deps.fs.mkdirPrivate(recordDir);
-  deps.fs.writeFilePrivate(recordFile, `${JSON.stringify({ accessToken, refreshToken, organizationUuid, accountUuid }, null, 2)}
+  deps.fs.writeFilePrivate(recordFile2, `${JSON.stringify({ accessToken, refreshToken, organizationUuid, accountUuid }, null, 2)}
 `);
-  return { identity: deps.identity, organizationUuid, credentialsFile, claudeJsonFile, recordFile, replaced: existingIsOwn };
+  return { identity: deps.identity, organizationUuid, credentialsFile, claudeJsonFile, recordFile: recordFile2, replaced: existingIsOwn };
 }
 
 // src/index.ts
@@ -21143,25 +21636,25 @@ init_ensure2();
 // src/frontdoor/liveSessionRegistry.ts
 init_capability();
 init_state();
-import path33 from "node:path";
+import path35 from "node:path";
 function sameStat(recorded, current) {
   return recorded?.mtimeMs === current.mtimeMs && recorded.sizeBytes === current.sizeBytes;
 }
 function createLiveSessionRegistry(ports) {
-  const { fs: fs14, sessionsDir } = ports;
+  const { fs: fs15, sessionsDir } = ports;
   const known = /* @__PURE__ */ new Map();
   let tokens = /* @__PURE__ */ new Set();
   let bySessionId = /* @__PURE__ */ new Map();
-  const recordNames = () => fs14.readdir(sessionsDir).filter(isSessionRecordName);
+  const recordNames = () => fs15.readdir(sessionsDir).filter(isSessionRecordName);
   const rebuildIndexes = () => {
     const records = [...known.values()].flatMap(({ record }) => record === void 0 ? [] : [record]);
     tokens = new Set(records.map((record) => record.token));
     bySessionId = new Map(records.flatMap((record) => record.sessionId === void 0 ? [] : [[record.sessionId, record]]));
   };
   const load = (name, stat) => {
-    known.set(name, { stat: { mtimeMs: stat.mtimeMs, sizeBytes: stat.sizeBytes }, record: readFrontDoorSessionRecord(fs14, sessionsDir, name) });
+    known.set(name, { stat: { mtimeMs: stat.mtimeMs, sizeBytes: stat.sizeBytes }, record: readFrontDoorSessionRecord(fs15, sessionsDir, name) });
   };
-  const statOf = (name) => fs14.lstat(path33.join(sessionsDir, name));
+  const statOf = (name) => fs15.lstat(path35.join(sessionsDir, name));
   const reconcile = () => {
     const names = new Set(recordNames());
     let changed = false;
@@ -21228,8 +21721,8 @@ init_plan2();
 init_poolPick();
 
 // src/agents/read.ts
-import path34 from "node:path";
-import { z as z34 } from "zod";
+import path36 from "node:path";
+import { z as z35 } from "zod";
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -21252,17 +21745,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(fs14, configDir) {
+function listSessions2(fs15, configDir) {
   const found = [];
-  for (const project of fs14.readdir(path34.join(configDir, PROJECTS_DIR))) {
-    const projectDir = path34.join(configDir, PROJECTS_DIR, project);
+  for (const project of fs15.readdir(path36.join(configDir, PROJECTS_DIR))) {
+    const projectDir = path36.join(configDir, PROJECTS_DIR, project);
     const entries = /* @__PURE__ */ new Set();
-    for (const name of fs14.readdir(projectDir)) {
+    for (const name of fs15.readdir(projectDir)) {
       if (name.endsWith(TRANSCRIPT_SUFFIX)) {
         entries.add(name.slice(0, -TRANSCRIPT_SUFFIX.length));
         continue;
       }
-      const children = fs14.readdir(path34.join(projectDir, name));
+      const children = fs15.readdir(path36.join(projectDir, name));
       if (children.includes(SUBAGENTS_DIR) || children.includes(WORKFLOWS_DIR)) {
         entries.add(name);
       }
@@ -21273,17 +21766,17 @@ function listSessions2(fs14, configDir) {
   }
   return found.sort((left, right) => left.project.localeCompare(right.project) || left.entry.localeCompare(right.entry));
 }
-function locateAgents(fs14, configDir, relativeDir, workflowRunId, report) {
+function locateAgents(fs15, configDir, relativeDir, workflowRunId, report) {
   const located = [];
-  for (const name of listDirOrReport(fs14, configDir, relativeDir, report)) {
+  for (const name of listDirOrReport(fs15, configDir, relativeDir, report)) {
     if (!name.startsWith(AGENT_FILE_PREFIX) || !name.endsWith(META_SUFFIX)) {
       continue;
     }
     const id = name.slice(AGENT_FILE_PREFIX.length, -META_SUFFIX.length);
     located.push({
       id,
-      metaPath: path34.join(relativeDir, name),
-      transcriptPath: path34.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
+      metaPath: path36.join(relativeDir, name),
+      transcriptPath: path36.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
       workflowRunId
     });
   }
@@ -21324,17 +21817,17 @@ function toNode(read, children) {
 function describeFailure(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function readFileOrReport(fs14, configDir, relative, report) {
+function readFileOrReport(fs15, configDir, relative, report) {
   try {
-    return fs14.readFileUtf8(path34.join(configDir, relative));
+    return fs15.readFileUtf8(path36.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be read: ${describeFailure(error)}` });
     return void 0;
   }
 }
-function listDirOrReport(fs14, configDir, relative, report) {
+function listDirOrReport(fs15, configDir, relative, report) {
   try {
-    return fs14.readdir(path34.join(configDir, relative));
+    return fs15.readdir(path36.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be listed: ${describeFailure(error)}` });
     return [];
@@ -21348,47 +21841,47 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = z34.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z34.array(z34.string()).default([]), blockedBy: z34.array(z34.string()).default([]) });
-var WorkflowRunFileSchema = z34.object({
-  runId: z34.string(),
-  workflowName: z34.string().optional(),
-  status: z34.string().optional(),
-  startTime: z34.number().optional(),
-  phases: z34.array(z34.object({ title: z34.string() })).default([]),
-  summary: z34.string().optional()
+var TaskFileSchema = z35.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z35.array(z35.string()).default([]), blockedBy: z35.array(z35.string()).default([]) });
+var WorkflowRunFileSchema = z35.object({
+  runId: z35.string(),
+  workflowName: z35.string().optional(),
+  status: z35.string().optional(),
+  startTime: z35.number().optional(),
+  phases: z35.array(z35.object({ title: z35.string() })).default([]),
+  summary: z35.string().optional()
 });
-function summariseSession(fs14, configDir, ref) {
-  const sessionRelative = path34.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = path34.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = path34.join(subagentsRelative, WORKFLOWS_DIR);
+function summariseSession(fs15, configDir, ref) {
+  const sessionRelative = path36.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path36.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path36.join(subagentsRelative, WORKFLOWS_DIR);
   const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
-  let agentCount = fs14.readdir(path34.join(configDir, subagentsRelative)).filter(isMeta).length;
-  for (const runDir of fs14.readdir(path34.join(configDir, workflowsUnderSubagents))) {
+  let agentCount = fs15.readdir(path36.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs15.readdir(path36.join(configDir, workflowsUnderSubagents))) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      agentCount += fs14.readdir(path34.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+      agentCount += fs15.readdir(path36.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
     }
   }
-  const workflowRunCount = fs14.readdir(path34.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
-  const transcript = fs14.lstat(path34.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
+  const workflowRunCount = fs15.readdir(path36.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs15.lstat(path36.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(fs14, configDir, ref, options = {}) {
+function readSessionAgentTree(fs15, configDir, ref, options = {}) {
   const problems = [];
   const report = (problem) => {
     problems.push(problem);
   };
-  const sessionRelative = path34.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = path34.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = path34.join(subagentsRelative, WORKFLOWS_DIR);
-  const located = locateAgents(fs14, configDir, subagentsRelative, void 0, report);
-  for (const runDir of listDirOrReport(fs14, configDir, workflowsUnderSubagents, report)) {
+  const sessionRelative = path36.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path36.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path36.join(subagentsRelative, WORKFLOWS_DIR);
+  const located = locateAgents(fs15, configDir, subagentsRelative, void 0, report);
+  for (const runDir of listDirOrReport(fs15, configDir, workflowsUnderSubagents, report)) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      located.push(...locateAgents(fs14, configDir, path34.join(workflowsUnderSubagents, runDir), runDir, report));
+      located.push(...locateAgents(fs15, configDir, path36.join(workflowsUnderSubagents, runDir), runDir, report));
     }
   }
   const agents = /* @__PURE__ */ new Map();
   for (const candidate of located) {
-    const text = readFileOrReport(fs14, configDir, candidate.metaPath, report);
+    const text = readFileOrReport(fs15, configDir, candidate.metaPath, report);
     if (text === void 0) {
       continue;
     }
@@ -21400,7 +21893,7 @@ function readSessionAgentTree(fs14, 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(fs14, configDir, agents, report);
+  const parentOf3 = resolveParents(fs15, configDir, agents, report);
   const childrenOf = /* @__PURE__ */ new Map();
   const roots = [];
   for (const id of agents.keys()) {
@@ -21423,12 +21916,12 @@ function readSessionAgentTree(fs14, configDir, ref, options = {}) {
     sessionId: ref.sessionId,
     superseded: ref.superseded,
     agents: roots.sort().map(build),
-    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, path34.join(sessionRelative, WORKFLOWS_DIR), report),
+    tasks: readTasks(fs15, configDir, ownTaskLists(ref.sessionId), [.../* @__PURE__ */ new Set([...teamNames, ...options.taskListIds ?? []])].filter((id) => !ownTaskLists(ref.sessionId).includes(id)), report),
+    workflowRuns: readWorkflowRuns(fs15, configDir, path36.join(sessionRelative, WORKFLOWS_DIR), report),
     problems
   };
 }
-function resolveParents(fs14, configDir, agents, report) {
+function resolveParents(fs15, configDir, agents, report) {
   const parentOf3 = /* @__PURE__ */ new Map();
   const transcriptCache = /* @__PURE__ */ new Map();
   const transcriptOf = (agent) => {
@@ -21436,7 +21929,7 @@ function resolveParents(fs14, configDir, agents, report) {
     if (cached !== void 0) {
       return cached;
     }
-    const text = readFileOrReport(fs14, configDir, agent.located.transcriptPath, report) ?? "";
+    const text = readFileOrReport(fs15, configDir, agent.located.transcriptPath, report) ?? "";
     transcriptCache.set(agent.located.id, text);
     return text;
   };
@@ -21486,16 +21979,16 @@ function resolveParents(fs14, configDir, agents, report) {
 function ownTaskLists(sessionId) {
   return [sessionId, `${SHORT_SESSION_LIST_PREFIX}${sessionId.slice(0, SHORT_SESSION_ID_LENGTH)}`];
 }
-function readTasks(fs14, configDir, ownLists, sharedLists, report) {
+function readTasks(fs15, configDir, ownLists, sharedLists, report) {
   const tasks = [];
   [...ownLists, ...sharedLists].forEach((scope, index) => {
-    const relativeDir = path34.join(TASKS_DIR, scope);
-    for (const name of [...listDirOrReport(fs14, configDir, relativeDir, report)].sort()) {
+    const relativeDir = path36.join(TASKS_DIR, scope);
+    for (const name of [...listDirOrReport(fs15, configDir, relativeDir, report)].sort()) {
       if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
         continue;
       }
-      const relative = path34.join(relativeDir, name);
-      const text = readFileOrReport(fs14, configDir, relative, report);
+      const relative = path36.join(relativeDir, name);
+      const text = readFileOrReport(fs15, 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 });
@@ -21506,14 +21999,14 @@ function readTasks(fs14, configDir, ownLists, sharedLists, report) {
   });
   return tasks;
 }
-function readWorkflowRuns(fs14, configDir, relativeDir, report) {
+function readWorkflowRuns(fs15, configDir, relativeDir, report) {
   const runs = [];
-  for (const name of [...listDirOrReport(fs14, configDir, relativeDir, report)].sort()) {
+  for (const name of [...listDirOrReport(fs15, configDir, relativeDir, report)].sort()) {
     if (!name.startsWith(WORKFLOW_RUN_PREFIX) || !name.endsWith(JSON_SUFFIX)) {
       continue;
     }
-    const relative = path34.join(relativeDir, name);
-    const text = readFileOrReport(fs14, configDir, relative, report);
+    const relative = path36.join(relativeDir, name);
+    const text = readFileOrReport(fs15, configDir, relative, report);
     const parsed = WorkflowRunFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
     if (!parsed.success) {
       if (text !== void 0) {
@@ -21529,7 +22022,7 @@ function readWorkflowRuns(fs14, configDir, relativeDir, report) {
 
 // src/agents/sessions.ts
 init_cliError();
-import path35 from "node:path";
+import path37 from "node:path";
 var SessionLookupError = class extends CliError {
   constructor(message) {
     super(message);
@@ -21537,13 +22030,13 @@ var SessionLookupError = class extends CliError {
   }
 };
 function identityConfigDir(identitiesDir, identity) {
-  return path35.join(identitiesDir, identity);
+  return path37.join(identitiesDir, identity);
 }
-function historyStores(fs14, identitiesDir, identities) {
+function historyStores(fs15, identitiesDir, identities) {
   const byRealPath = /* @__PURE__ */ new Map();
   for (const identity of identities) {
     const configDir = identityConfigDir(identitiesDir, identity);
-    const real = fs14.realpath(path35.join(configDir, "projects"));
+    const real = fs15.realpath(path37.join(configDir, "projects"));
     if (real === void 0) {
       continue;
     }
@@ -21556,15 +22049,15 @@ function historyStores(fs14, identitiesDir, identities) {
   }
   return [...byRealPath.values()];
 }
-function collectSessionList(fs14, identitiesDir, identities, filters) {
+function collectSessionList(fs15, 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(fs14, identitiesDir, names)) {
-    for (const ref of listSessions2(fs14, store.configDir)) {
-      const summary = summariseSession(fs14, store.configDir, ref);
+  for (const store of historyStores(fs15, identitiesDir, names)) {
+    for (const ref of listSessions2(fs15, store.configDir)) {
+      const summary = summariseSession(fs15, store.configDir, ref);
       if (filters.all === true || summary.agentCount > 0 || summary.workflowRunCount > 0) {
         sessions.push({ ...summary, identities: store.identities });
       }
@@ -21572,14 +22065,14 @@ function collectSessionList(fs14, identitiesDir, identities, filters) {
   }
   return sessions.sort((left, right) => (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "") || left.sessionId.localeCompare(right.sessionId));
 }
-function locateSession(fs14, identitiesDir, identities, query, onlyIdentity) {
+function locateSession(fs15, 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(fs14, identitiesDir, names)) {
-    for (const ref of listSessions2(fs14, store.configDir)) {
+  for (const store of historyStores(fs15, identitiesDir, names)) {
+    for (const ref of listSessions2(fs15, store.configDir)) {
       if (ref.sessionId.startsWith(query)) {
         matches.push({ identities: store.identities, configDir: store.configDir, ref });
       }
@@ -21596,9 +22089,9 @@ function locateSession(fs14, 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(fs14, identitiesDir, identities, query, onlyIdentity) {
-  const located = locateSession(fs14, identitiesDir, identities, query, onlyIdentity);
-  return { identities: located.identities, tree: readSessionAgentTree(fs14, located.configDir, located.ref) };
+function showSession(fs15, identitiesDir, identities, query, onlyIdentity) {
+  const located = locateSession(fs15, identitiesDir, identities, query, onlyIdentity);
+  return { identities: located.identities, tree: readSessionAgentTree(fs15, located.configDir, located.ref) };
 }
 
 // src/agents/realFs.ts
@@ -21753,6 +22246,7 @@ export {
   CodexRateLimitsReadSchema,
   CodexSignInSchema,
   CodexStatusOutputSchema,
+  ConfigIdentityAddInputSchema,
   ConfigIdentityAddOutputSchema,
   ConfigIdentityRemoveInputSchema,
   ConfigIdentityRemoveOutputSchema,