agent-shim 8.5.6 → 8.7.0

package/dist/index.cjs

@@ -75,6 +75,7 @@ __export(index_exports, {
   ProviderSchema: () => ProviderSchema,
   RC_IDLE_EXPIRY_MS: () => RC_IDLE_EXPIRY_MS,
   RC_PENDING_DEADLINE_MS: () => RC_PENDING_DEADLINE_MS,
+  RC_PERMISSION_MODES: () => RC_PERMISSION_MODES,
   RC_REQUEST_PARSE_CAP_BYTES: () => RC_REQUEST_PARSE_CAP_BYTES,
   RC_SESSIONS_PATH_PREFIX: () => RC_SESSIONS_PATH_PREFIX,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
@@ -91,6 +92,9 @@ __export(index_exports, {
   buildLayoutPaths: () => buildLayoutPaths,
   buildRcControlResponsePayload: () => buildRcControlResponsePayload,
   buildRcEventWriteBody: () => buildRcEventWriteBody,
+  buildRcInterruptPayload: () => buildRcInterruptPayload,
+  buildRcSetModelPayload: () => buildRcSetModelPayload,
+  buildRcSetPermissionModePayload: () => buildRcSetPermissionModePayload,
   buildRcUserMessagePayload: () => buildRcUserMessagePayload,
   carryOver: () => carryOver,
   checkReportHasWarnings: () => checkReportHasWarnings,
@@ -115,8 +119,10 @@ __export(index_exports, {
   generateCa: () => generateCa,
   identityExists: () => identityExists,
   injectRcUserMessage: () => injectRcUserMessage,
+  interruptRcSession: () => interruptRcSession,
   isIdentityDirectoryName: () => isIdentityDirectoryName,
   isInterceptedHost: () => isInterceptedHost,
+  isRcPermissionMode: () => isRcPermissionMode,
   listDirectoryRules: () => listDirectoryRules,
   listIdentities: () => listIdentities,
   listProfiles: () => listProfiles,
@@ -172,6 +178,8 @@ __export(index_exports, {
   setProfileEntries: () => setProfileEntries,
   setProfileLaunchFlags: () => setProfileLaunchFlags,
   setProfileMetadata: () => setProfileMetadata,
+  setRcSessionModel: () => setRcSessionModel,
+  setRcSessionPermissionMode: () => setRcSessionPermissionMode,
   snapshotPath: () => snapshotPath,
   startConnectServer: () => startConnectServer,
   topLevelNames: () => topLevelNames,
@@ -4070,6 +4078,19 @@ function buildRcControlResponsePayload(requestId, decision) {
   const result = decision.approve ? { behavior: "allow" } : { behavior: "deny", message: decision.message ?? "" };
   return { type: "control_response", response: { subtype: "success", request_id: requestId, response: result } };
 }
+var RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
+function isRcPermissionMode(value) {
+  return RC_PERMISSION_MODES.some((mode) => mode === value);
+}
+function buildRcInterruptPayload(requestId) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "interrupt" } };
+}
+function buildRcSetModelPayload(requestId, model) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "set_model", model } };
+}
+function buildRcSetPermissionModePayload(requestId, mode) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "set_permission_mode", mode } };
+}
 async function answerRcControlRequest(deps, sessionId, requestId, decision) {
   const credential = deps.credentialOf(sessionId);
   if (credential === void 0) {
@@ -4094,9 +4115,64 @@ async function answerRcControlRequest(deps, sessionId, requestId, decision) {
   }
   return result;
 }
+async function interruptRcSession(deps, sessionId) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcInterruptPayload(deps.newUuid())));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to interrupt session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return rcEventWriteResultFromAnswer(answer);
+}
+async function setRcSessionModel(deps, sessionId, model) {
+  if (model === "") {
+    return { ok: false, message: "a set-model write needs a non-empty model id: the SDK's own field treats an omitted or null value as a reset to the session default, which this operation never sends, and an empty string is neither" };
+  }
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetModelPayload(deps.newUuid(), model)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to set the model on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return rcEventWriteResultFromAnswer(answer);
+}
+async function setRcSessionPermissionMode(deps, sessionId, mode) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
+  }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetPermissionModePayload(deps.newUuid(), mode)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to set the permission mode on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return rcEventWriteResultFromAnswer(answer);
+}
 
 // src/frontdoor/rcControl.ts
 var https2 = __toESM(require("node:https"), 1);
+var RC_PERMISSION_MODE_LIST = RC_PERMISSION_MODES.join(", ");
 var CONTROL_PATH_PREFIX = "/__agent-shim/rc";
 var CONTROL_BODY_CAP_BYTES = 10485760;
 function answerJson(response, status, body) {
@@ -4131,6 +4207,9 @@ function createRcControlHandler(deps) {
   const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
   const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
   const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
+  const interruptPath = `${CONTROL_PATH_PREFIX}/interrupt`;
+  const setModelPath = `${CONTROL_PATH_PREFIX}/set-model`;
+  const setPermissionModePath = `${CONTROL_PATH_PREFIX}/set-permission-mode`;
   return (request4, response) => {
     const presented = request4.headers.authorization;
     const bearerPrefix = "bearer ".length;
@@ -4215,6 +4294,78 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
         return;
       }
+      if (url.pathname === interruptPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the interrupt operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || typeof parsed.session !== "string" || parsed.session === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body must be JSON naming a non-empty session id" });
+          return;
+        }
+        const result = await deps.interrupt(parsed.session);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
+      if (url.pathname === setModelPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-model operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("model" in parsed) || typeof parsed.session !== "string" || typeof parsed.model !== "string" || parsed.session === "" || parsed.model === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body must be JSON naming a non-empty session id and model id" });
+          return;
+        }
+        const result = await deps.setModel(parsed.session, parsed.model);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, model: parsed.model, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
+      if (url.pathname === setPermissionModePath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-permission-mode operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-permission-mode body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("mode" in parsed) || typeof parsed.session !== "string" || parsed.session === "" || !isRcPermissionMode(parsed.mode)) {
+          answerJson(response, HTTP_STATUS.badRequest, { error: `the set-permission-mode body must be JSON naming a non-empty session id and a mode the SDK's own type permits (${RC_PERMISSION_MODE_LIST})` });
+          return;
+        }
+        const result = await deps.setPermissionMode(parsed.session, parsed.mode);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, mode: parsed.mode, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
+      }
       answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url.pathname}` });
     };
     handle().catch((error) => {
@@ -4429,7 +4580,10 @@ function frontDoorRcControl(transport, token) {
       `${CONTROL_PATH_PREFIX}/answer`,
       JSON.stringify({ session: sessionId, request: requestId, approve: decision.approve, ...decision.approve || decision.message === void 0 ? {} : { text: decision.message } }),
       (status, message) => `answering control request ${requestId} on ${sessionId} failed (HTTP ${String(status)}): ${message}`
-    )
+    ),
+    interruptSession: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/interrupt`, JSON.stringify({ session: sessionId }), (status, message) => `interrupting ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    setModel: async (sessionId, model) => await writeOf(`${CONTROL_PATH_PREFIX}/set-model`, JSON.stringify({ session: sessionId, model }), (status, message) => `setting the model on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    setPermissionMode: async (sessionId, mode) => await writeOf(`${CONTROL_PATH_PREFIX}/set-permission-mode`, JSON.stringify({ session: sessionId, mode }), (status, message) => `setting the permission mode on ${sessionId} failed (HTTP ${String(status)}): ${message}`)
   };
 }
 
@@ -5872,6 +6026,56 @@ var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/credentialCache.ts
 var import_zod7 = require("zod");
+
+// src/usage/preflight.ts
+var MS_PER_SECOND2 = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
+function formatAge(ms) {
+  const minutes = Math.floor(ms / (MS_PER_SECOND2 * SECONDS_PER_MINUTE));
+  if (minutes < MINUTES_PER_HOUR) {
+    return `${String(Math.max(minutes, 0))}m`;
+  }
+  const hours = Math.floor(minutes / MINUTES_PER_HOUR);
+  return hours < HOURS_PER_DAY ? `${String(hours)}h` : `${String(Math.floor(hours / HOURS_PER_DAY))}d`;
+}
+function effectiveWindow(window, nowMs) {
+  const resetsAtMs = window.resetsAt === void 0 ? void 0 : Date.parse(window.resetsAt);
+  if (resetsAtMs !== void 0 && resetsAtMs <= nowMs) {
+    return { reset: true, utilization: 0 };
+  }
+  return {
+    reset: false,
+    ...window.utilization === void 0 ? {} : { utilization: window.utilization },
+    ...resetsAtMs === void 0 ? {} : { resetsAtMs },
+    ...window.status === void 0 ? {} : { status: window.status }
+  };
+}
+function quotaWarnings(snapshot, provider, nowMs) {
+  const rateLimit = snapshot?.providers[provider]?.rateLimit;
+  const unified = rateLimit?.unified;
+  if (snapshot === void 0 || rateLimit === void 0 || unified === void 0) {
+    return [];
+  }
+  const age = formatAge(nowMs - Date.parse(rateLimit.observedAt));
+  const windows = [
+    { name: "five-hour", window: unified.fiveHour },
+    { name: "seven-day", window: unified.sevenDay }
+  ];
+  return windows.flatMap(({ name, window }) => {
+    const effective = window === void 0 ? void 0 : effectiveWindow(window, nowMs);
+    if (window === void 0 || effective?.status === void 0 || !WARNING_STATUSES.has(effective.status)) {
+      return [];
+    }
+    const reset = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
+    const verdict = effective.status === "rejected" ? "exhausted" : "nearly used";
+    return [`agent-shim: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
+  });
+}
+
+// src/credentialCache.ts
 var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
 var CachedCredentialSchema = import_zod7.z.strictObject({
   token: import_zod7.z.string().min(1),
@@ -5898,6 +6102,45 @@ function isFresh(entry, cache, now) {
   }
   return limit === void 0 || now - entry.fetchedAt < limit;
 }
+function cacheAgeMs(entry, now) {
+  return Math.max(0, now - entry.fetchedAt);
+}
+function describeCachedCredential(params) {
+  const store = effectiveStore(params.cache, params.platform);
+  let entry;
+  try {
+    entry = params.port.read(store, params.owner);
+  } catch (error) {
+    return { store, status: "unreadable", reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (entry === void 0) {
+    return { store, status: "empty" };
+  }
+  const limit = ttlMs(params.cache);
+  const ageMs = cacheAgeMs(entry, params.nowMs);
+  return {
+    store,
+    status: isFresh(entry, params.cache, params.nowMs) ? "fresh" : "expired",
+    ageMs,
+    ...limit === void 0 ? {} : { expiresInMs: limit - ageMs }
+  };
+}
+function formatCachedCredentialState(state) {
+  if (state.status === "empty") {
+    return `no cached entry in the ${state.store} store yet`;
+  }
+  if (state.status === "unreadable") {
+    return `the ${state.store} store cannot be read here: ${state.reason}`;
+  }
+  if (state.status === "expired" && (state.expiresInMs === void 0 || state.expiresInMs > 0)) {
+    return "cached with a timestamp in the future, treated as expired";
+  }
+  const age = `cached ${formatAge(state.ageMs)} ago`;
+  if (state.expiresInMs === void 0) {
+    return `${age}, no expiry`;
+  }
+  return state.status === "fresh" ? `${age}, expires in ${formatAge(state.expiresInMs)}` : `${age}, expired ${formatAge(-state.expiresInMs)} ago`;
+}
 
 // src/credential.ts
 var CREDENTIAL_UNAVAILABLE_EXIT = 64;
@@ -6513,54 +6756,6 @@ function readDirectorySelections(loaded) {
   return { ...identity === void 0 ? {} : { identity }, ...configProfile === void 0 ? {} : { configProfile } };
 }
 
-// src/usage/preflight.ts
-var MS_PER_SECOND2 = 1e3;
-var SECONDS_PER_MINUTE = 60;
-var MINUTES_PER_HOUR = 60;
-var HOURS_PER_DAY = 24;
-var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
-function formatAge(ms) {
-  const minutes = Math.floor(ms / (MS_PER_SECOND2 * SECONDS_PER_MINUTE));
-  if (minutes < MINUTES_PER_HOUR) {
-    return `${String(Math.max(minutes, 0))}m`;
-  }
-  const hours = Math.floor(minutes / MINUTES_PER_HOUR);
-  return hours < HOURS_PER_DAY ? `${String(hours)}h` : `${String(Math.floor(hours / HOURS_PER_DAY))}d`;
-}
-function effectiveWindow(window, nowMs) {
-  const resetsAtMs = window.resetsAt === void 0 ? void 0 : Date.parse(window.resetsAt);
-  if (resetsAtMs !== void 0 && resetsAtMs <= nowMs) {
-    return { reset: true, utilization: 0 };
-  }
-  return {
-    reset: false,
-    ...window.utilization === void 0 ? {} : { utilization: window.utilization },
-    ...resetsAtMs === void 0 ? {} : { resetsAtMs },
-    ...window.status === void 0 ? {} : { status: window.status }
-  };
-}
-function quotaWarnings(snapshot, provider, nowMs) {
-  const rateLimit = snapshot?.providers[provider]?.rateLimit;
-  const unified = rateLimit?.unified;
-  if (snapshot === void 0 || rateLimit === void 0 || unified === void 0) {
-    return [];
-  }
-  const age = formatAge(nowMs - Date.parse(rateLimit.observedAt));
-  const windows = [
-    { name: "five-hour", window: unified.fiveHour },
-    { name: "seven-day", window: unified.sevenDay }
-  ];
-  return windows.flatMap(({ name, window }) => {
-    const effective = window === void 0 ? void 0 : effectiveWindow(window, nowMs);
-    if (window === void 0 || effective?.status === void 0 || !WARNING_STATUSES.has(effective.status)) {
-      return [];
-    }
-    const reset = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
-    const verdict = effective.status === "rejected" ? "exhausted" : "nearly used";
-    return [`agent-shim: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
-  });
-}
-
 // src/usage/poolPick.ts
 var import_node_path19 = __toESM(require("node:path"), 1);
 var import_zod9 = require("zod");
@@ -6956,19 +7151,97 @@ function collectPoolPick(params) {
   };
 }
 
-// src/realPorts.ts
+// src/realCredentialCache.ts
 var import_node_child_process = require("node:child_process");
-var import_node_crypto9 = require("node:crypto");
 var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
+var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
+var CACHE_DIR_MODE = 448;
+var CACHE_FILE_MODE = 384;
+function cacheFileNameFor(owner) {
+  return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
+}
+function parseEntry(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const parsed = CachedCredentialSchema.safeParse(json);
+  return parsed.success ? parsed.data : void 0;
+}
+function requireKeychain() {
+  if (process.platform !== "darwin") {
+    throw new Error("the keychain credential store needs macOS; use --credential-cache-store file");
+  }
+}
+function security(args, stdin) {
+  const result = (0, import_node_child_process.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
+  return { status: result.status, stdout: result.stdout };
+}
+function createRealCredentialCache(root) {
+  const dir = import_node_path20.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path20.default.join(dir, cacheFileNameFor(owner));
+  return {
+    read(store, owner) {
+      if (store === "file") {
+        try {
+          return parseEntry(import_node_fs6.default.readFileSync(filePath(owner), "utf8"));
+        } catch {
+          return void 0;
+        }
+      }
+      requireKeychain();
+      const result = security(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
+      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
+    },
+    write(store, owner, entry) {
+      const serialised = JSON.stringify(entry);
+      if (store === "file") {
+        import_node_fs6.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
+        import_node_fs6.default.chmodSync(dir, CACHE_DIR_MODE);
+        const target = filePath(owner);
+        const temp = `${target}.${String(process.pid)}.tmp`;
+        import_node_fs6.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
+        import_node_fs6.default.renameSync(temp, target);
+        return;
+      }
+      requireKeychain();
+      const encoded = Buffer.from(serialised, "utf8").toString("base64");
+      const result = security(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
+`);
+      if (result.status !== 0) {
+        throw new Error(`could not write the keychain credential cache for ${owner}`);
+      }
+    },
+    remove(store, owner) {
+      if (store === "file") {
+        import_node_fs6.default.rmSync(filePath(owner), { force: true });
+        return;
+      }
+      requireKeychain();
+      security(["delete-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner]);
+    }
+  };
+}
+function realCredentialCacheEnv(paths) {
+  return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
+}
+
+// src/realPorts.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto9 = require("node:crypto");
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 var import_node_sea = require("node:sea");
 
 // src/versionDiscovery.ts
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 function defaultVersionsDir() {
-  return import_node_path20.default.join(import_node_os2.default.homedir(), ".local", "share", "claude", "versions");
+  return import_node_path21.default.join(import_node_os2.default.homedir(), ".local", "share", "claude", "versions");
 }
 var NUMERIC_DOTTED_VERSION_RE = /^\d+(?:\.\d+)*$/;
 function isNumericDottedVersion(name) {
@@ -7010,7 +7283,7 @@ function discoverClaudeBinary(options) {
   const highestVersion = pickHighestVersion(entries);
   if (highestVersion !== void 0) {
     return {
-      path: import_node_path20.default.join(versionsDir, highestVersion),
+      path: import_node_path21.default.join(versionsDir, highestVersion),
       source: "versions-dir",
       version: highestVersion
     };
@@ -7033,7 +7306,7 @@ function isEnoent3(error) {
 var realFsPort = {
   readFileUtf8(filePath) {
     try {
-      return import_node_fs6.default.readFileSync(filePath, "utf8");
+      return import_node_fs7.default.readFileSync(filePath, "utf8");
     } catch (error) {
       if (isEnoent3(error)) {
         return void 0;
@@ -7044,7 +7317,7 @@ var realFsPort = {
   readConfigFile: cosmiconfigReader(),
   readdir(dirPath) {
     try {
-      return import_node_fs6.default.readdirSync(dirPath);
+      return import_node_fs7.default.readdirSync(dirPath);
     } catch (error) {
       if (isEnoent3(error)) {
         return [];
@@ -7063,7 +7336,7 @@ var realFarmFs = {
   lstat(filePath) {
     let stat;
     try {
-      stat = import_node_fs6.default.lstatSync(filePath);
+      stat = import_node_fs7.default.lstatSync(filePath);
     } catch (error) {
       if (isEnoent3(error)) {
         return void 0;
@@ -7075,7 +7348,7 @@ var realFarmFs = {
   },
   readdir(dirPath) {
     try {
-      return import_node_fs6.default.readdirSync(dirPath);
+      return import_node_fs7.default.readdirSync(dirPath);
     } catch (error) {
       if (isEnoent3(error) || isErrorWithCode(error, "ENOTDIR")) {
         return [];
@@ -7084,23 +7357,23 @@ var realFarmFs = {
     }
   },
   mkdirp(dirPath) {
-    import_node_fs6.default.mkdirSync(dirPath, { recursive: true });
+    import_node_fs7.default.mkdirSync(dirPath, { recursive: true });
   },
   symlink(target, linkPath) {
-    import_node_fs6.default.symlinkSync(target, linkPath);
+    import_node_fs7.default.symlinkSync(target, linkPath);
   },
   rename(from, to) {
-    import_node_fs6.default.renameSync(from, to);
+    import_node_fs7.default.renameSync(from, to);
   },
   removeRecursive(targetPath) {
-    import_node_fs6.default.rmSync(targetPath, { recursive: true, force: true });
+    import_node_fs7.default.rmSync(targetPath, { recursive: true, force: true });
   },
   copyRecursive(from, to) {
-    import_node_fs6.default.cpSync(from, to, { recursive: true, force: true, verbatimSymlinks: true });
+    import_node_fs7.default.cpSync(from, to, { recursive: true, force: true, verbatimSymlinks: true });
   },
   readFileUtf8(filePath) {
     try {
-      return import_node_fs6.default.readFileSync(filePath, "utf8");
+      return import_node_fs7.default.readFileSync(filePath, "utf8");
     } catch (error) {
       if (isEnoent3(error)) {
         return void 0;
@@ -7109,36 +7382,36 @@ var realFarmFs = {
     }
   },
   writeFileUtf8(filePath, contents) {
-    import_node_fs6.default.writeFileSync(filePath, contents, "utf8");
+    import_node_fs7.default.writeFileSync(filePath, contents, "utf8");
   },
   mkdirPrivate(dirPath) {
-    import_node_fs6.default.mkdirSync(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
-    import_node_fs6.default.chmodSync(dirPath, OWNER_ONLY_DIR_MODE);
+    import_node_fs7.default.mkdirSync(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
+    import_node_fs7.default.chmodSync(dirPath, OWNER_ONLY_DIR_MODE);
   },
   writeFilePrivate(filePath, contents) {
     const temp = `${filePath}.${String(process.pid)}.tmp`;
-    import_node_fs6.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-    import_node_fs6.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
-    import_node_fs6.default.renameSync(temp, filePath);
+    import_node_fs7.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+    import_node_fs7.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
+    import_node_fs7.default.renameSync(temp, filePath);
   },
   appendFilePrivate(filePath, contents) {
-    const descriptor = import_node_fs6.default.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
+    const descriptor = import_node_fs7.default.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
     try {
-      if ((import_node_fs6.default.fstatSync(descriptor).mode & PERMISSION_BITS2) !== OWNER_ONLY_FILE_MODE) {
-        import_node_fs6.default.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
+      if ((import_node_fs7.default.fstatSync(descriptor).mode & PERMISSION_BITS2) !== OWNER_ONLY_FILE_MODE) {
+        import_node_fs7.default.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
       }
       const bytes = Buffer.from(contents, "utf8");
       let written = 0;
       while (written < bytes.length) {
-        written += import_node_fs6.default.writeSync(descriptor, bytes, written, bytes.length - written);
+        written += import_node_fs7.default.writeSync(descriptor, bytes, written, bytes.length - written);
       }
     } finally {
-      import_node_fs6.default.closeSync(descriptor);
+      import_node_fs7.default.closeSync(descriptor);
     }
   },
   writeFileExclusive(filePath, contents) {
     try {
-      import_node_fs6.default.writeFileSync(filePath, contents, { encoding: "utf8", flag: "wx" });
+      import_node_fs7.default.writeFileSync(filePath, contents, { encoding: "utf8", flag: "wx" });
       return true;
     } catch (error) {
       if (isErrorWithCode(error, "EEXIST")) {
@@ -7149,7 +7422,7 @@ var realFarmFs = {
   },
   hashFile(filePath) {
     try {
-      return (0, import_node_crypto9.createHash)("sha256").update(import_node_fs6.default.readFileSync(filePath)).digest("hex");
+      return (0, import_node_crypto9.createHash)("sha256").update(import_node_fs7.default.readFileSync(filePath)).digest("hex");
     } catch (error) {
       if (isEnoent3(error) || isErrorWithCode(error, "EISDIR")) {
         return void 0;
@@ -7171,7 +7444,7 @@ function realIsProcessAlive(pid) {
   }
 }
 function realIsProcessZombie(pid) {
-  const result = (0, import_node_child_process.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
+  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
   return result.status === 0 && result.stdout.trim().startsWith("Z");
 }
 function realIsProcessRunning(pid) {
@@ -7179,17 +7452,17 @@ function realIsProcessRunning(pid) {
 }
 var realRunPort = {
   run(command, args) {
-    const result = (0, import_node_child_process.spawnSync)(command, [...args], { encoding: "utf8" });
+    const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
     return { status: result.status, stdout: result.stdout, stderr: result.stderr };
   }
 };
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? import_node_path21.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? import_node_path22.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
   if (process.platform === "darwin") {
-    const result = (0, import_node_child_process.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
+    const result = (0, import_node_child_process2.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
     return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
   }
   if (process.platform === "win32") {
@@ -7203,8 +7476,8 @@ var realCredentialPort = {
     let content;
     let stat;
     try {
-      stat = import_node_fs6.default.statSync(resolved);
-      content = import_node_fs6.default.readFileSync(resolved, "utf8");
+      stat = import_node_fs7.default.statSync(resolved);
+      content = import_node_fs7.default.readFileSync(resolved, "utf8");
     } catch (error) {
       if (isEnoent3(error)) {
         return { found: false };
@@ -7215,7 +7488,7 @@ var realCredentialPort = {
   },
   runCommand(argv, options) {
     const [command, ...args] = argv;
-    const result = (0, import_node_child_process.spawnSync)(command, args, {
+    const result = (0, import_node_child_process2.spawnSync)(command, args, {
       encoding: "utf8",
       timeout: options.timeoutMs,
       stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"]
@@ -7257,17 +7530,17 @@ function spawnDaemonThrough(executable) {
   return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs6.default.mkdirSync(import_node_path21.default.dirname(logPath), { recursive: true });
-  const logFd = import_node_fs6.default.openSync(logPath, "a");
+  import_node_fs7.default.mkdirSync(import_node_path22.default.dirname(logPath), { recursive: true });
+  const logFd = import_node_fs7.default.openSync(logPath, "a");
   try {
-    const child = (0, import_node_child_process.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
+    const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
     child.unref();
     if (child.pid === void 0) {
       throw new Error(`spawning ${subcommand} returned no pid`);
     }
     return child.pid;
   } finally {
-    import_node_fs6.default.closeSync(logFd);
+    import_node_fs7.default.closeSync(logFd);
   }
 }
 function spawnHeadroomSupervisor(paths, spawnDaemon) {
@@ -7285,7 +7558,7 @@ var realHeadroomSocketTrust = {
   lstat: (target) => {
     let stat;
     try {
-      stat = import_node_fs6.default.lstatSync(target);
+      stat = import_node_fs7.default.lstatSync(target);
     } catch (error) {
       if (isEnoent3(error)) {
         return void 0;
@@ -7331,7 +7604,7 @@ var EXECUTE_BITS_MASK = 73;
 function listVersionsDir(dir) {
   let entries;
   try {
-    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs7.default.readdirSync(dir, { withFileTypes: true });
   } catch (error) {
     if (isEnoent3(error)) {
       return [];
@@ -7339,8 +7612,8 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path21.default.join(dir, entry.name);
-    const stat = import_node_fs6.default.statSync(fullPath);
+    const fullPath = import_node_path22.default.join(dir, entry.name);
+    const stat = import_node_fs7.default.statSync(fullPath);
     return {
       name: entry.name,
       isFile: true,
@@ -7354,7 +7627,7 @@ function windowsPathExtensions(pathext) {
   return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
 }
 function resolveExecutableCandidate(dir, name, env) {
-  const candidate = import_node_path21.default.join(dir, name);
+  const candidate = import_node_path22.default.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -7374,7 +7647,7 @@ function resolveExecutableCandidate(dir, name, env) {
 }
 function realStatFileMode(candidate) {
   try {
-    const stat = import_node_fs6.default.statSync(candidate);
+    const stat = import_node_fs7.default.statSync(candidate);
     return stat.isFile() ? stat.mode : void 0;
   } catch (error) {
     if (isEnoent3(error)) {
@@ -7403,13 +7676,13 @@ function resolveOwnExecutablePath(env) {
   if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
     return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
   }
-  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path21.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path21.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path21.default.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path22.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path22.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path22.default.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path21.default.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path22.default.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -7417,7 +7690,7 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path21.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path22.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
@@ -7430,14 +7703,14 @@ function realContentSourcePath() {
 function realResolveClaudeBinary(isOwnBinary) {
   return () => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path21.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path22.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     isOwnBinary
   });
 }
 
 // src/checkReport.ts
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 var import_zod10 = require("zod");
 
 // src/cli/bool.ts
@@ -7607,14 +7880,23 @@ function inspectSettingsExposure(params) {
   }
   return reports;
 }
-function buildCredentialReport(provider, identity) {
+function cachedState(cacheEnv, owner, block) {
+  if (cacheEnv === void 0 || block.cache === void 0) {
+    return void 0;
+  }
+  return describeCachedCredential({ port: cacheEnv.port, platform: cacheEnv.platform, owner, cache: block.cache, nowMs: cacheEnv.now() });
+}
+function buildCredentialReport(provider, identity, identityName, cacheEnv) {
   const identityCredential = identity?.credential === void 0 ? void 0 : summariseCredential(identity.credential);
+  const identityCached = identity?.credential === void 0 || identityName === void 0 ? void 0 : cachedState(cacheEnv, `identity ${identityName}`, identity.credential);
+  const providerCached = provider?.definition === void 0 ? void 0 : cachedState(cacheEnv, `provider ${provider.name}`, provider.definition.credential);
   return {
     applies: provider !== void 0 ? "provider" : identityCredential !== void 0 ? "identity" : "stored-login",
     ...provider === void 0 ? {} : {
-      provider: provider.problem === void 0 ? { name: provider.name, credential: summariseCredential(provider.definition.credential) } : { name: provider.name, problem: provider.problem }
+      provider: provider.problem === void 0 ? { name: provider.name, credential: summariseCredential(provider.definition.credential), ...providerCached === void 0 ? {} : { cached: providerCached } } : { name: provider.name, problem: provider.problem }
     },
-    ...identityCredential === void 0 ? {} : { identity: identityCredential }
+    ...identityCredential === void 0 ? {} : { identity: identityCredential },
+    ...identityCached === void 0 ? {} : { identityCached }
   };
 }
 function runCheck(params) {
@@ -7653,7 +7935,7 @@ function runCheck(params) {
     ambientCredential,
     ...keychain === void 0 ? {} : { keychain },
     settingsExposure,
-    credential: buildCredentialReport(params.provider, params.identity)
+    credential: buildCredentialReport(params.provider, params.identity, params.identityName, params.credentialCache)
   };
 }
 function formatCheckReport(report) {
@@ -7691,12 +7973,12 @@ function formatCheckReport(report) {
   const { credential } = report;
   if (credential.provider !== void 0) {
     lines.push(
-      `  Provider ${credential.provider.name}: ${credential.provider.credential === void 0 ? `unusable: ${credential.provider.problem ?? ""}` : formatCredentialSummary(credential.provider.credential)}`
+      `  Provider ${credential.provider.name}: ${credential.provider.credential === void 0 ? `unusable: ${credential.provider.problem ?? ""}` : formatCredentialSummary(credential.provider.credential)}${credential.provider.cached === void 0 ? "" : `; ${formatCachedCredentialState(credential.provider.cached)}`}`
     );
   }
   if (credential.identity !== void 0) {
     lines.push(
-      `  Identity ${report.identityName ?? "(none)"}: ${formatCredentialSummary(credential.identity)}${credential.applies === "provider" ? " (not used: the provider's credential applies)" : ""}`
+      `  Identity ${report.identityName ?? "(none)"}: ${formatCredentialSummary(credential.identity)}${credential.identityCached === void 0 ? "" : `; ${formatCachedCredentialState(credential.identityCached)}`}${credential.applies === "provider" ? " (not used: the provider's credential applies)" : ""}`
     );
   }
   if (credential.applies === "stored-login") {
@@ -7805,10 +8087,10 @@ function collectCheckReport(params) {
   }).input;
   const providerName = cascadeProviderName(cascade);
   const provider = providerName === void 0 ? void 0 : loadCheckProvider(paths, providerName);
-  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path22.default.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path23.default.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(import_node_path22.default.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(import_node_path22.default.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(import_node_path23.default.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(import_node_path23.default.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -7829,6 +8111,7 @@ function collectCheckReport(params) {
     ...loadedIdentity === void 0 ? {} : { identity: loadedIdentity.config },
     settingsFiles,
     run: realRunPort,
+    credentialCache: realCredentialCacheEnv(paths),
     ...farmRoot === void 0 ? {} : { farmRoot },
     platform: process.platform,
     ...provider === void 0 ? {} : { provider }
@@ -7837,8 +8120,8 @@ function collectCheckReport(params) {
 }
 
 // src/claudeShim.ts
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 var import_zod11 = require("zod");
 var ClaudeShimStateSchema = import_zod11.z.strictObject({
   targetPath: import_zod11.z.string().min(1),
@@ -7850,10 +8133,10 @@ function commandFilename(ownExecutablePath, commandName) {
 }
 function resolveOwnBinaryCheck(paths, contentSourcePath) {
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const recordedTarget = state === void 0 ? void 0 : import_node_path23.default.resolve(state.targetPath);
+  const recordedTarget = state === void 0 ? void 0 : import_node_path24.default.resolve(state.targetPath);
   let ownStat;
   return (candidate) => {
-    if (recordedTarget !== void 0 && import_node_path23.default.resolve(candidate) === recordedTarget) {
+    if (recordedTarget !== void 0 && import_node_path24.default.resolve(candidate) === recordedTarget) {
       return true;
     }
     ownStat ??= statOrUndefined(contentSourcePath);
@@ -7867,7 +8150,7 @@ function isEnoent4(error) {
 }
 function statOrUndefined(target) {
   try {
-    return import_node_fs7.default.statSync(target);
+    return import_node_fs8.default.statSync(target);
   } catch (error) {
     if (isEnoent4(error)) {
       return void 0;
@@ -7875,22 +8158,22 @@ function statOrUndefined(target) {
     throw error;
   }
 }
-var nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
+var nodeLinkFs = { link: import_node_fs8.default.linkSync, copyFile: import_node_fs8.default.copyFileSync, chmod: import_node_fs8.default.chmodSync };
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path23.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path24.default.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return import_node_path23.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path24.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path23.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path24.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 
 // src/doctorReport.ts
-var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -7914,7 +8197,7 @@ function validateJson(schema, input) {
   return { ok: true, data: result.data };
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = import_node_path24.default.dirname(resolution.ownExecutablePath);
+  const ownDir = import_node_path25.default.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");
@@ -7956,7 +8239,14 @@ function pushPathResolution(push, resolution) {
       break;
   }
 }
-function pushProvider(push, entry) {
+function cacheClause(cacheEnv, owner, block) {
+  if (cacheEnv === void 0 || block.cache === void 0) {
+    return { text: "", unreadable: false };
+  }
+  const state = describeCachedCredential({ port: cacheEnv.port, platform: cacheEnv.platform, owner, cache: block.cache, nowMs: cacheEnv.now() });
+  return { text: `; ${formatCachedCredentialState(state)}`, unreadable: state.status === "unreadable" };
+}
+function pushProvider(push, entry, cacheEnv) {
   if (entry.raw === void 0) {
     push("provider", "fail", `${entry.path} is missing.`, entry.name);
     return;
@@ -7978,18 +8268,19 @@ function pushProvider(push, entry) {
     push("provider", "fail", new ConfigValidationError(entry.path, validated.error.issues).message, entry.name);
     return;
   }
-  push("provider", "pass", `${entry.name} is valid (${describeProviderEndpoint(validated.data)}, credential ${describeCredential(validated.data.credential)}).`, entry.name);
+  const cache = cacheClause(cacheEnv, `provider ${entry.name}`, validated.data.credential);
+  push("provider", cache.unreadable ? "fail" : "pass", `${entry.name} is valid (${describeProviderEndpoint(validated.data)}, credential ${describeCredential(validated.data.credential)})${cache.text}.`, entry.name);
 }
 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 && import_node_path24.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && import_node_path25.default.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 (import_node_path24.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (import_node_path25.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -8071,10 +8362,11 @@ function runDoctor(params) {
       );
     } else {
       const credential = validated.data.credential;
+      const cache = credential === void 0 ? { text: "", unreadable: false } : cacheClause(params.credentialCache, `identity ${entry.name}`, credential);
       push(
         "identity",
-        "pass",
-        `${entry.name} is valid and authenticates with ${credential === void 0 ? "its stored login" : `credential ${describeCredential(credential)}`}.`,
+        cache.unreadable ? "fail" : "pass",
+        `${entry.name} is valid and authenticates with ${credential === void 0 ? "its stored login" : `credential ${describeCredential(credential)}`}${cache.text}.`,
         entry.name
       );
     }
@@ -8094,7 +8386,7 @@ function runDoctor(params) {
     return poolName === void 0 ? validIdentityNames.has(selector) : poolName in pools;
   };
   for (const entry of params.providers) {
-    pushProvider(push, entry);
+    pushProvider(push, entry, params.credentialCache);
   }
   if (params.platform !== "darwin" || params.run === void 0) {
     push("keychain", "pass", "Skipped (not macOS).");
@@ -8288,27 +8580,27 @@ function formatDoctorReport(report) {
 }
 function realpathOrSelf(target) {
   try {
-    return import_node_fs8.default.realpathSync(target);
+    return import_node_fs9.default.realpathSync(target);
   } catch {
     return target;
   }
 }
 function collectDoctorReport(params) {
   const { paths } = params;
-  const identityNames = import_node_fs8.default.existsSync(paths.identitiesDir) ? import_node_fs8.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
+  const identityNames = import_node_fs9.default.existsSync(paths.identitiesDir) ? import_node_fs9.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = import_node_path24.default.join(paths.identitiesDir, name);
-    const identityPath = import_node_path24.default.join(farmRoot, "identity.json");
+    const farmRoot = import_node_path25.default.join(paths.identitiesDir, name);
+    const identityPath = import_node_path25.default.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
   });
-  const profileNames = import_node_fs8.default.existsSync(paths.configProfilesDir) ? import_node_fs8.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+  const profileNames = import_node_fs9.default.existsSync(paths.configProfilesDir) ? import_node_fs9.default.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 = import_node_path24.default.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = import_node_path25.default.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
-  const providerNames = import_node_fs8.default.existsSync(paths.providersDir) ? import_node_fs8.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+  const providerNames = import_node_fs9.default.existsSync(paths.providersDir) ? import_node_fs9.default.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 = import_node_path24.default.join(paths.providersDir, `${name}.json`);
+    const providerPath = import_node_path25.default.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -8320,12 +8612,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(import_node_path24.default.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(import_node_path25.default.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: import_node_path24.default.dirname(shimState.targetPath),
-      targetFilename: import_node_path24.default.basename(shimState.targetPath),
+      targetDir: import_node_path25.default.dirname(shimState.targetPath),
+      targetFilename: import_node_path25.default.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -8333,6 +8625,7 @@ function collectDoctorReport(params) {
   );
   const report = runDoctor({
     env: params.env,
+    credentialCache: realCredentialCacheEnv(paths),
     identities,
     configProfiles,
     providers,
@@ -8341,14 +8634,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 && import_node_fs8.default.existsSync(shimState.targetPath) },
+    claudeShim: { state: shimState, targetExists: shimState !== void 0 && import_node_fs9.default.existsSync(shimState.targetPath) },
     rootPath: paths.root,
     pathResolution: {
       ownExecutablePath,
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: import_node_path24.default.dirname(ownExecutablePath),
+          targetDir: import_node_path25.default.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -8369,7 +8662,7 @@ function collectDoctorReport(params) {
 
 // src/launcher.ts
 var import_node_crypto10 = require("node:crypto");
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 
 // src/launcher/argv.ts
 var ConflictingIdentityError = class extends UsageError {
@@ -8621,7 +8914,7 @@ function buildCliOverride(params) {
 }
 
 // src/launcher/flags.ts
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 
 // src/headroom/headers.ts
 function mergeAnthropicCustomHeaders(existing, additions) {
@@ -8691,7 +8984,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path25.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path26.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -8852,7 +9145,7 @@ function prepareLaunch(params) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path26.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path27.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -9025,84 +9318,6 @@ function prepareLaunch(params) {
 var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_crypto12 = require("node:crypto");
 
-// src/realCredentialCache.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path27 = __toESM(require("node:path"), 1);
-var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
-var CACHE_DIR_MODE = 448;
-var CACHE_FILE_MODE = 384;
-function cacheFileNameFor(owner) {
-  return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
-}
-function parseEntry(raw) {
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-  const parsed = CachedCredentialSchema.safeParse(json);
-  return parsed.success ? parsed.data : void 0;
-}
-function requireKeychain() {
-  if (process.platform !== "darwin") {
-    throw new Error("the keychain credential store needs macOS; use --credential-cache-store file");
-  }
-}
-function security(args, stdin) {
-  const result = (0, import_node_child_process2.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
-  return { status: result.status, stdout: result.stdout };
-}
-function createRealCredentialCache(root) {
-  const dir = import_node_path27.default.join(root, "credential-cache");
-  const filePath = (owner) => import_node_path27.default.join(dir, cacheFileNameFor(owner));
-  return {
-    read(store, owner) {
-      if (store === "file") {
-        try {
-          return parseEntry(import_node_fs9.default.readFileSync(filePath(owner), "utf8"));
-        } catch {
-          return void 0;
-        }
-      }
-      requireKeychain();
-      const result = security(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
-      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
-    },
-    write(store, owner, entry) {
-      const serialised = JSON.stringify(entry);
-      if (store === "file") {
-        import_node_fs9.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
-        import_node_fs9.default.chmodSync(dir, CACHE_DIR_MODE);
-        const target = filePath(owner);
-        const temp = `${target}.${String(process.pid)}.tmp`;
-        import_node_fs9.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
-        import_node_fs9.default.renameSync(temp, target);
-        return;
-      }
-      requireKeychain();
-      const encoded = Buffer.from(serialised, "utf8").toString("base64");
-      const result = security(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
-`);
-      if (result.status !== 0) {
-        throw new Error(`could not write the keychain credential cache for ${owner}`);
-      }
-    },
-    remove(store, owner) {
-      if (store === "file") {
-        import_node_fs9.default.rmSync(filePath(owner), { force: true });
-        return;
-      }
-      requireKeychain();
-      security(["delete-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner]);
-    }
-  };
-}
-function realCredentialCacheEnv(paths) {
-  return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
-}
-
 // src/frontdoor/realFrontDoorPort.ts
 var import_node_fs10 = __toESM(require("node:fs"), 1);
 
@@ -9379,6 +9594,7 @@ function prepareClaudeLaunch(options) {
   ProviderSchema,
   RC_IDLE_EXPIRY_MS,
   RC_PENDING_DEADLINE_MS,
+  RC_PERMISSION_MODES,
   RC_REQUEST_PARSE_CAP_BYTES,
   RC_SESSIONS_PATH_PREFIX,
   ROUTED_PATH_PREFIX,
@@ -9395,6 +9611,9 @@ function prepareClaudeLaunch(options) {
   buildLayoutPaths,
   buildRcControlResponsePayload,
   buildRcEventWriteBody,
+  buildRcInterruptPayload,
+  buildRcSetModelPayload,
+  buildRcSetPermissionModePayload,
   buildRcUserMessagePayload,
   carryOver,
   checkReportHasWarnings,
@@ -9419,8 +9638,10 @@ function prepareClaudeLaunch(options) {
   generateCa,
   identityExists,
   injectRcUserMessage,
+  interruptRcSession,
   isIdentityDirectoryName,
   isInterceptedHost,
+  isRcPermissionMode,
   listDirectoryRules,
   listIdentities,
   listProfiles,
@@ -9476,6 +9697,8 @@ function prepareClaudeLaunch(options) {
   setProfileEntries,
   setProfileLaunchFlags,
   setProfileMetadata,
+  setRcSessionModel,
+  setRcSessionPermissionMode,
   snapshotPath,
   startConnectServer,
   topLevelNames,