claude-use 9.12.1 → 9.14.0

package/dist/index.cjs

@@ -228,7 +228,15 @@ function isCodexProvider(provider) {
 function poolMemberIdentity(member) {
   return typeof member === "string" ? member : member.identity;
 }
-var import_node_path2, import_zod, import_trilean, CATEGORY_NAMES, OVERRIDABLE_CATEGORIES, CategoryMapSchema, DURATION_RE, DurationSchema, WhenConditionObjectSchema, WhenSchema, EntryValueSchema, ENTRY_KEY_RE, EntriesSchema, LaunchSchema, CREDENTIAL_TARGETS, PROVIDER_CREDENTIAL_TARGETS, CREDENTIAL_TARGET_VARS, ArgvSchema, CommandSourceOptions, EnvCredentialSourceSchema, FileCredentialSourceSchema, CommandCredentialSourceSchema, OpCredentialSourceSchema, KeychainCredentialSourceSchema, LiteralCredentialSourceSchema, CredentialSourceSchema, RemoteCredentialSourceSchema, CREDENTIAL_CACHE_STORES, CredentialCacheSchema, CredentialSchema, ProviderCredentialSchema, RESERVED_PROVIDER_ENV_KEYS, ProviderEnvSchema, PROVIDER_KINDS, CODEX_EFFORTS, CODEX_LOGINS, CODEX_DEFAULT_TIER_MODELS, CodexProviderConfigSchema, ProviderRouteSchema, HttpProviderSchema, CodexProviderSchema, ProviderSchema, ConfigProfileSchema, POOL_SELECTOR_PREFIX, POOL_NAME_PATTERN, IDENTITY_NAME_PATTERN, PoolNameSchema, SELECTOR_RE, IdentitySelectorSchema, PoolMemberSchema, POOL_PREFERENCES, PoolPreferenceSchema, PoolSchema, DirectoryRuleSchema, DirectoryRulesSchema, PortableConfigSchema, HEADROOM_MODES, HEADROOM_CCR_MODES, HEADROOM_ROLLOUT_CHANNELS, INTERCEPT_CHANNELS, READ_MATURATION_CHANNELS, HeadroomGlobalConfigObjectSchema, HeadroomGlobalConfigSchema, HEADROOM_DEFAULT_SOURCE, HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES, FrontDoorGlobalConfigSchema, UPDATE_MODES, UpdateGlobalConfigSchema, GlobalConfigSchema, IdentitySchema, CategoryClassificationSchema, CategoryClassificationOverlaySchema, SHIPPED_CATEGORY_DEFAULTS;
+function isTimeZone(name) {
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: name });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var import_node_path2, import_zod, import_trilean, CATEGORY_NAMES, OVERRIDABLE_CATEGORIES, CategoryMapSchema, DURATION_RE, DurationSchema, WhenConditionObjectSchema, WhenSchema, EntryValueSchema, ENTRY_KEY_RE, EntriesSchema, LaunchSchema, CREDENTIAL_TARGETS, PROVIDER_CREDENTIAL_TARGETS, CREDENTIAL_TARGET_VARS, ArgvSchema, CommandSourceOptions, EnvCredentialSourceSchema, FileCredentialSourceSchema, CommandCredentialSourceSchema, OpCredentialSourceSchema, KeychainCredentialSourceSchema, LiteralCredentialSourceSchema, CredentialSourceSchema, RemoteCredentialSourceSchema, CREDENTIAL_CACHE_STORES, CredentialCacheSchema, CredentialSchema, ProviderCredentialSchema, RESERVED_PROVIDER_ENV_KEYS, ProviderEnvSchema, PROVIDER_KINDS, CODEX_EFFORTS, CODEX_LOGINS, CODEX_DEFAULT_TIER_MODELS, CodexProviderConfigSchema, ProviderRouteSchema, HttpProviderSchema, CodexProviderSchema, ProviderSchema, ConfigProfileSchema, POOL_SELECTOR_PREFIX, POOL_NAME_PATTERN, IDENTITY_NAME_PATTERN, PoolNameSchema, SELECTOR_RE, IdentitySelectorSchema, PoolMemberSchema, POOL_PREFERENCES, PoolPreferenceSchema, PoolSchema, DirectoryRuleSchema, DirectoryRulesSchema, PortableConfigSchema, HEADROOM_MODES, HEADROOM_CCR_MODES, HEADROOM_ROLLOUT_CHANNELS, INTERCEPT_CHANNELS, READ_MATURATION_CHANNELS, HeadroomGlobalConfigObjectSchema, HeadroomGlobalConfigSchema, HEADROOM_DEFAULT_SOURCE, HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES, FrontDoorGlobalConfigSchema, UPDATE_MODES, UpdateGlobalConfigSchema, GlobalConfigSchema, WEEKDAYS, AnchorSchema, IdentitySchema, CategoryClassificationSchema, CategoryClassificationOverlaySchema, SHIPPED_CATEGORY_DEFAULTS;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
@@ -468,12 +476,20 @@ var init_schema = __esm({
       update: UpdateGlobalConfigSchema.optional(),
       pools: import_zod.z.record(PoolNameSchema, PoolSchema).optional()
     });
+    WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+    AnchorSchema = import_zod.z.strictObject({
+      days: import_zod.z.array(import_zod.z.enum(WEEKDAYS)).min(1).refine((days) => new Set(days).size === days.length, "an anchor names each weekday at most once"),
+      time: import_zod.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "a 24-hour time such as 06:00"),
+      timeZone: import_zod.z.string().refine(isTimeZone, "an IANA time zone such as Europe/London").optional()
+    });
     IdentitySchema = import_zod.z.strictObject({
       $schema: import_zod.z.string().optional(),
       name: import_zod.z.string().min(1).regex(/^[A-Za-z0-9][A-Za-z0-9._@-]*$/),
       defaultConfigProfile: import_zod.z.string().min(1).optional(),
       allowAmbientCredential: import_zod.z.boolean().default(false),
-      credential: CredentialSchema.optional()
+      credential: CredentialSchema.optional(),
+      /** When this identity's five-hour window should be open: the front door opens one at each anchor if none is. Absent, nothing is opened on a schedule. */
+      anchors: import_zod.z.array(AnchorSchema).min(1).optional()
     });
     CategoryClassificationSchema = import_zod.z.strictObject({
       $schema: import_zod.z.string().optional(),
@@ -2595,7 +2611,7 @@ function listFrontDoorSessions(fs12, sessionsDir) {
     try {
       const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs12.readFileUtf8(import_node_path8.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
-        sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
+        sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt, ...parsed.data.supervisorPid === void 0 ? {} : { supervisorPid: parsed.data.supervisorPid } });
       }
     } catch {
       continue;
@@ -2623,7 +2639,7 @@ var init_state = __esm({
     import_node_path8 = __toESM(require("node:path"), 1);
     import_zod3 = require("zod");
     FRONT_DOOR_PROTOCOL = 3;
-    FrontDoorSessionSchema = import_zod3.z.strictObject({ pid: import_zod3.z.number().int().positive(), startedAt: import_zod3.z.number(), token: import_zod3.z.string().min(1) });
+    FrontDoorSessionSchema = import_zod3.z.strictObject({ pid: import_zod3.z.number().int().positive(), startedAt: import_zod3.z.number(), token: import_zod3.z.string().min(1), supervisorPid: import_zod3.z.number().int().positive().optional() });
     FrontDoorStateSchema = import_zod3.z.strictObject({
       /**
        * The launcher-to-door wire protocol this supervisor speaks, written once it is serving; absent in state written by a release that predates the field, which `ensureFrontDoor` reads as protocol 0. A launcher replaces a door whose protocol is lower than its own (see `FRONT_DOOR_PROTOCOL`).
@@ -2663,7 +2679,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.12.1",
+      version: "9.14.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -2766,6 +2782,36 @@ var init_package = __esm({
   }
 });
 
+// src/frontdoor/supervisorProcesses.ts
+function parseFrontDoorSupervisorPids(psOutput) {
+  const pids = [];
+  for (const line of psOutput.split("\n")) {
+    const [pidText, ...argumentsList] = line.trim().split(/\s+/);
+    const pid = Number(pidText);
+    if (Number.isInteger(pid) && pid > 0 && argumentsList.includes(FRONT_DOOR_SUPERVISOR_ARGUMENT)) {
+      pids.push(pid);
+    }
+  }
+  return pids.sort((a, b) => a - b);
+}
+function listFrontDoorSupervisors(run, uid) {
+  const result = run.run("ps", ["-U", String(uid), "-o", "pid=,command="]);
+  if (result.status === null) {
+    return { ok: false, message: "ps could not be run" };
+  }
+  if (result.status !== 0) {
+    return { ok: false, message: `ps exited ${String(result.status)}${result.stderr.trim() === "" ? "" : `: ${result.stderr.trim()}`}` };
+  }
+  return { ok: true, pids: parseFrontDoorSupervisorPids(result.stdout) };
+}
+var FRONT_DOOR_SUPERVISOR_ARGUMENT;
+var init_supervisorProcesses = __esm({
+  "src/frontdoor/supervisorProcesses.ts"() {
+    "use strict";
+    FRONT_DOOR_SUPERVISOR_ARGUMENT = "__frontdoor-supervisor";
+  }
+});
+
 // src/headroom/state.ts
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
@@ -3363,9 +3409,15 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
+function currentHeadroomAllowlistInputs(fs12, paths) {
+  return {
+    providers: readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider),
+    frontDoorOrigin: frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))
+  };
+}
 function currentHeadroomAllowlist(fs12, paths) {
-  const providers = readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))));
+  const inputs = currentHeadroomAllowlistInputs(fs12, paths);
+  return headroomAllowlist(headroomUpstreams(inputs.providers, inputs.frontDoorOrigin));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -3428,8 +3480,8 @@ function realIsProcessRunning(pid) {
   return realIsProcessAlive(pid) && !realIsProcessZombie(pid);
 }
 function realIsFrontDoorSupervisor(pid) {
-  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" });
-  return result.status === 0 && result.stdout.split(/\s+/).includes(FRONT_DOOR_SUPERVISOR_SUBCOMMAND);
+  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "pid=,command=", "-p", String(pid)], { encoding: "utf8" });
+  return result.status === 0 && parseFrontDoorSupervisorPids(result.stdout).includes(pid);
 }
 function expandHome2(filePath) {
   return filePath.startsWith("~/") ? import_node_path13.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
@@ -3628,7 +3680,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var import_node_child_process2, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path13, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, FRONT_DOOR_SUPERVISOR_SUBCOMMAND, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
+var import_node_child_process2, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path13, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
 var init_realPorts = __esm({
   "src/realPorts.ts"() {
     "use strict";
@@ -3640,6 +3692,7 @@ var init_realPorts = __esm({
     import_node_sea = require("node:sea");
     init_load();
     init_versionDiscovery();
+    init_supervisorProcesses();
     init_ensure();
     init_supervisor();
     init_state2();
@@ -3769,7 +3822,6 @@ var init_realPorts = __esm({
       }
     };
     INT32_BYTE_LENGTH = 4;
-    FRONT_DOOR_SUPERVISOR_SUBCOMMAND = "__frontdoor-supervisor";
     realRunPort = {
       run(command, args) {
         const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
@@ -4676,7 +4728,7 @@ function assessIdentity(member, nowMs) {
   );
   if (blockedUntil > nowMs) {
     if (unified.overageStatus === "allowed") {
-      return { candidate: { ...base, class: "pay-per-use", reasons: [`plan exhausted until ${new Date(blockedUntil).toISOString()}, continues as extra usage`, ...windowReasons, ...planReasons] } };
+      return { candidate: { ...base, class: "pay-per-use", planReturnsAtMs: blockedUntil, reasons: [`plan exhausted until ${new Date(blockedUntil).toISOString()} (in ${formatAge(blockedUntil - nowMs)}), continues as extra usage`, ...windowReasons, ...planReasons] } };
     }
     return { candidate: { ...base, class: "ineligible", blockedUntilMs: blockedUntil, reasons: [`refused until ${new Date(blockedUntil).toISOString()} (in ${formatAge(blockedUntil - nowMs)})`, ...unified.fallbackAvailable === true ? ["a fallback is on offer, so requests for some models may still be served"] : [], ...windowReasons, ...overageReasons, ...planReasons] } };
   }
@@ -4791,7 +4843,8 @@ function rankPool(input) {
   return {
     candidates: ordered,
     ...pick === void 0 ? { ...earliestReturn === void 0 ? {} : { earliestReturn } } : { pick },
-    ...movedOff === void 0 || pick === void 0 ? {} : { movedOff }
+    ...movedOff === void 0 || pick === void 0 ? {} : { movedOff },
+    ...pick?.planReturnsAtMs === void 0 ? {} : { planReturn: { identity: pick.identity, atMs: pick.planReturnsAtMs } }
   };
 }
 var MS_PER_SECOND4, MS_PER_HOUR2, HOURS_PER_DAY2, FIVE_HOURS, PROMPT_CACHE_TTL_HOURS, PERCENT, SEVEN_DAYS, FIVE_HOUR_WINDOW_MS, SEVEN_DAY_WINDOW_MS, PROMPT_CACHE_TTL_MS, CLASS_ORDER;
@@ -5270,6 +5323,7 @@ function buildLayoutPaths(root) {
     usageLogDir: import_node_path22.default.join(root, "usage", "log"),
     usageSnapshotsDir: import_node_path22.default.join(root, "usage", "snapshots"),
     usagePicksFile: import_node_path22.default.join(root, "usage", "picks.json"),
+    usageAnchorsFile: import_node_path22.default.join(root, "usage", "anchors.json"),
     mcpPermissionsFile: import_node_path22.default.join(root, "mcp", "permissions.json")
   };
 }
@@ -6204,7 +6258,7 @@ function ensureFrontDoor(params) {
         }
         if (verdict.ok) {
           const token = (0, import_node_crypto9.randomUUID)();
-          writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token });
+          writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token, supervisorPid });
           return { port: state.port, connectPort: state.connectPort, token };
         }
         lastRejection = `the listener on 127.0.0.1:${String(state.port)} (recorded for pid ${String(supervisorPid)}) failed authentication: ${verdict.reason}`;
@@ -6739,7 +6793,12 @@ function resolvePoolLaunch(params) {
     if (graph.ranking.candidates.length === 0) {
       return { ok: false, message: `agent-shim: no member of pool "${poolName}" is an existing identity.` };
     }
-    const { pick, earliestReturn, movedOff } = graph.ranking;
+    const { pick, earliestReturn, movedOff, planReturn } = graph.ranking;
+    if (pick !== void 0 && params.wait && planReturn !== void 0) {
+      log.info(`agent-shim: pool "${poolName}" would continue ${planReturn.identity} on extra usage; waiting until ${new Date(planReturn.atMs).toISOString()} for its plan window`);
+      params.sleep(Math.max(planReturn.atMs - nowMs, 0));
+      continue;
+    }
     if (pick !== void 0) {
       if (params.recordPick) {
         recordStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd, pick.identity, nowMs);
@@ -7767,6 +7826,57 @@ var init_anthropicUsageRefresh = __esm({
   }
 });
 
+// src/usage/identityClaude.ts
+function definedEnvironment(env) {
+  return Object.fromEntries(Object.entries(env).flatMap(([name, value]) => value === void 0 ? [] : [[name, value]]));
+}
+function identityLaunchArgv(identity, flags) {
+  return [`@${identity}`, IDENTITY_ONLY_FLAG, ...flags];
+}
+async function withIdentityClaude(params, identity, flags, use) {
+  const refusals = [];
+  const plan = prepareLaunch(
+    realPrepareLaunchParams(params.paths, {
+      proc: {
+        env: Object.fromEntries(Object.entries(process.env).filter(([name]) => name !== CONFIG_DIR_VARIABLE)),
+        argv: [...identityLaunchArgv(identity, flags)],
+        exit: (code) => {
+          throw new LaunchRefusedError(refusals.join("\n") || `the launch was refused (exit ${String(code)})`, code);
+        }
+      },
+      log: {
+        info: () => void 0,
+        warn: () => void 0,
+        error: (message) => {
+          refusals.push(message);
+        }
+      },
+      spawnDaemon: params.spawnDaemon,
+      farm: buildFarmRuntime(params.paths, params.cwd)
+    })
+  );
+  const abort = new AbortController();
+  const timer = setTimeout(() => {
+    abort.abort();
+  }, params.timeoutMs);
+  try {
+    return await use({ bin: plan.bin, env: definedEnvironment(plan.env), cwd: params.cwd, abort });
+  } finally {
+    clearTimeout(timer);
+    plan.release();
+  }
+}
+var CONFIG_DIR_VARIABLE, IDENTITY_ONLY_FLAG;
+var init_identityClaude = __esm({
+  "src/usage/identityClaude.ts"() {
+    "use strict";
+    init_launchWiring();
+    init_launcher();
+    CONFIG_DIR_VARIABLE = "CLAUDE_CONFIG_DIR";
+    IDENTITY_ONLY_FLAG = "--no-provider";
+  }
+});
+
 // src/usage/providerQuota.ts
 var import_zod25, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY4, 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_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
 var init_providerQuota = __esm({
@@ -7837,9 +7947,6 @@ var realAnthropicUsageProbe_exports = {};
 __export(realAnthropicUsageProbe_exports, {
   createRealAnthropicUsageRefresher: () => createRealAnthropicUsageRefresher
 });
-function definedEnvironment(env) {
-  return Object.fromEntries(Object.entries(env).flatMap(([name, value]) => value === void 0 ? [] : [[name, value]]));
-}
 function idlePrompt(signal) {
   return {
     [Symbol.asyncIterator]: () => ({
@@ -7852,58 +7959,28 @@ function idlePrompt(signal) {
   };
 }
 function createRealAnthropicUsageProbe(params) {
-  return async (identity) => {
-    const refusals = [];
-    const plan = prepareLaunch(
-      realPrepareLaunchParams(params.paths, {
-        proc: {
-          env: Object.fromEntries(Object.entries(process.env).filter(([name]) => name !== CONFIG_DIR_VARIABLE)),
-          argv: [`@${identity}`, ...PROBE_LAUNCH_FLAGS],
-          exit: (code) => {
-            throw new LaunchRefusedError(refusals.join("\n") || `the launch was refused (exit ${String(code)})`, code);
-          }
-        },
-        log: {
-          info: () => void 0,
-          warn: () => void 0,
-          error: (message) => {
-            refusals.push(message);
-          }
-        },
-        spawnDaemon: params.spawnDaemon,
-        farm: buildFarmRuntime(params.paths, params.cwd)
-      })
-    );
+  return async (identity) => await withIdentityClaude(params, identity, PROBE_LAUNCH_FLAGS, async ({ bin, env, cwd, abort }) => {
     const { query } = await import("@anthropic-ai/claude-agent-sdk");
-    const abort = new AbortController();
-    const timer = setTimeout(() => {
-      abort.abort();
-    }, params.timeoutMs);
-    try {
-      const session = query({
-        prompt: idlePrompt(abort.signal),
-        options: {
-          pathToClaudeCodeExecutable: plan.bin,
-          env: definedEnvironment(plan.env),
-          cwd: params.cwd,
-          abortController: abort,
-          settingSources: [],
-          mcpServers: {},
-          strictMcpConfig: true,
-          persistSession: false
-        }
-      });
-      try {
-        const report = await session.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({ skipBehaviors: true });
-        return unifiedFromReportedLimits(report.rate_limits_available ? report.rate_limits : null);
-      } finally {
-        session.close();
+    const session = query({
+      prompt: idlePrompt(abort.signal),
+      options: {
+        pathToClaudeCodeExecutable: bin,
+        env,
+        cwd,
+        abortController: abort,
+        settingSources: [],
+        mcpServers: {},
+        strictMcpConfig: true,
+        persistSession: false
       }
+    });
+    try {
+      const report = await session.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({ skipBehaviors: true });
+      return unifiedFromReportedLimits(report.rate_limits_available ? report.rate_limits : null);
     } finally {
-      clearTimeout(timer);
-      plan.release();
+      session.close();
     }
-  };
+  });
 }
 function createRealAnthropicUsageRefresher(params) {
   return createAnthropicUsageRefresher({
@@ -7916,18 +7993,16 @@ function createRealAnthropicUsageRefresher(params) {
     concurrency: (0, import_node_os8.availableParallelism)()
   });
 }
-var import_node_os8, PROBE_LAUNCH_FLAGS, CONFIG_DIR_VARIABLE;
+var import_node_os8, PROBE_LAUNCH_FLAGS;
 var init_realAnthropicUsageProbe = __esm({
   "src/usage/realAnthropicUsageProbe.ts"() {
     "use strict";
     import_node_os8 = require("node:os");
-    init_launchWiring();
-    init_launcher();
     init_anthropicUsageRefresh();
+    init_identityClaude();
     init_middleware();
     init_quotaRefresh();
     PROBE_LAUNCH_FLAGS = ["--no-headroom", "--no-remote-control"];
-    CONFIG_DIR_VARIABLE = "CLAUDE_CONFIG_DIR";
   }
 });
 
@@ -8701,16 +8776,27 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http3.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   let idleSince;
   let ticks = 0;
+  const supersedingOwner = () => {
+    const owner = readFrontDoorState(fs12, paths.frontdoorStateFile)?.supervisorPid;
+    return owner !== void 0 && owner !== ports.ownPid && ports.isRunning(owner) ? owner : void 0;
+  };
+  let supersededBy;
+  let served;
   const binaryReplaced = () => {
     const current = ports.statOwnExecutable();
     return current !== void 0 && servingBinary !== void 0 && (current.dev !== servingBinary.dev || current.ino !== servingBinary.ino || current.size !== servingBinary.size || current.mtimeMs !== servingBinary.mtimeMs);
   };
-  const shutdown = async () => {
+  const closeServing = async () => {
     await direct.close();
     await connect3.close();
     await http3.close();
     ports.closeRcStreamHub();
-    writeFrontDoorState(fs12, paths.frontdoorStateFile, sticky());
+  };
+  const shutdown = async () => {
+    await closeServing();
+    if (supersedingOwner() === void 0) {
+      writeFrontDoorState(fs12, paths.frontdoorStateFile, sticky());
+    }
     return 0;
   };
   for (; ; ) {
@@ -8723,7 +8809,28 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ports.observeLaunchRegistry(listed, pruned);
     ports.checkQuotaExpiry();
     const prunedPids = new Set(pruned);
-    if (listed.filter((session) => !prunedPids.has(session.pid)).length === 0) {
+    const live = listed.filter((session) => !prunedPids.has(session.pid));
+    if (supersededBy === void 0) {
+      supersededBy = supersedingOwner();
+      if (supersededBy !== void 0) {
+        ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: supervisor ${String(supersededBy)} now owns the front door; taking no new sessions and exiting once the sessions this door serves have ended`);
+        ports.doorHealth.superseded(supersededBy);
+        await ports.sleep(FRONTDOOR_POLL_MS);
+        continue;
+      }
+    } else {
+      const owner = supersededBy;
+      served = (served ?? live.filter((session) => session.pid !== ports.ownPid && session.pid !== owner && (session.supervisorPid === void 0 || session.supervisorPid === ports.ownPid))).filter((own) => live.some((session) => session.pid === own.pid && session.startedAt === own.startedAt));
+      if (served.length === 0) {
+        ports.log("agent-shim frontdoor supervisor: the sessions this superseded door served have ended; closing the front door and exiting");
+        ports.doorHealth.drained();
+        await closeServing();
+        return 0;
+      }
+      await ports.sleep(FRONTDOOR_POLL_MS);
+      continue;
+    }
+    if (live.length === 0) {
       if (ticks > 1 && binaryReplaced()) {
         ports.log("agent-shim frontdoor supervisor: the installed binary changed and no sessions are live; turning the door over for the next launch");
         ports.doorHealth.binaryTurnover();
@@ -12715,6 +12822,12 @@ function listIdentities(paths) {
   }
   return result;
 }
+function setIdentityAnchors(paths, identityName, anchors) {
+  if (!identityExists(paths, identityName)) {
+    throw new IdentityNotFoundError(identityName);
+  }
+  return applyPatch(identityJsonPath(paths, identityName), IdentitySchema, { anchors: anchors === void 0 ? void 0 : [...anchors] });
+}
 function setDefaultConfigProfile(paths, identityName, profileName) {
   if (!identityExists(paths, identityName)) {
     throw new IdentityNotFoundError(identityName);
@@ -12877,7 +12990,55 @@ init_credential();
 init_credentialCache();
 init_realCredentialCache();
 init_source();
+
+// src/headroom/allowlistDrift.ts
+init_state2();
+function diagnoseAllowlistDrift(params) {
+  const { recordedHash, providers, frontDoorOrigin: frontDoorOrigin2 } = params;
+  if (recordedHash === void 0 || recordedHash === hashAllowlist(headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin2)))) {
+    return void 0;
+  }
+  const originIsInput = providers.length > 0 && frontDoorOrigin2 !== void 0;
+  if (!originIsInput) {
+    return ["provider-files"];
+  }
+  return recordedHash === hashAllowlist(headroomAllowlist(headroomUpstreams(providers, void 0))) ? ["front-door-origin"] : ["provider-files", "front-door-origin"];
+}
+
+// src/doctorReport.ts
 init_state2();
+init_supervisor();
+init_state();
+
+// src/doctorFrontDoor.ts
+function pushFrontDoor(push, supervisors, registeredPid) {
+  if (!supervisors.ok) {
+    push("frontdoor", "warn", `Could not list processes to look for duplicate front door supervisors: ${supervisors.message}.`);
+    return;
+  }
+  const { pids } = supervisors;
+  if (pids.length === 0) {
+    push("frontdoor", "pass", "No front door supervisor is running.");
+    return;
+  }
+  const [only, ...rest] = pids;
+  if (only !== void 0 && rest.length === 0) {
+    push("frontdoor", "pass", `One front door supervisor is running (pid ${String(only)}).`);
+    return;
+  }
+  const serving = registeredPid !== void 0 && pids.includes(registeredPid) ? `The front door state file names pid ${String(registeredPid)} as the serving supervisor.` : "The front door state file names no running supervisor.";
+  for (const pid of pids.filter((candidate) => candidate !== registeredPid)) {
+    push(
+      "frontdoor",
+      "fail",
+      `Front door supervisor pid ${String(pid)} is running beside ${String(pids.length - 1)} other(s). ${serving} Stop it with \`kill ${String(pid)}\`; launches still connected to it lose their door.`,
+      String(pid)
+    );
+  }
+}
+
+// src/doctorReport.ts
+init_supervisorProcesses();
 init_legacy();
 init_providersStore();
 init_guard();
@@ -12900,7 +13061,8 @@ var DOCTOR_SECTIONS = [
   "global-config",
   "categories-local",
   "active-identity",
-  "headroom"
+  "headroom",
+  "frontdoor"
 ];
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
@@ -13296,6 +13458,17 @@ function runDoctor(params) {
           `Headroom daemon is up on unix socket ${state.socketPath} (supervisor ${String(state.supervisorPid)}, daemon ${String(state.headroomPid)}).`
         );
       }
+      const allowlist = params.headroom.allowlist;
+      if (supervisorAlive && headroomAlive && state.socketPath !== void 0 && allowlist?.driftInputs?.includes("front-door-origin") === true) {
+        const origin = allowlist.frontDoorOrigin ?? "";
+        const certainty = allowlist.driftInputs.includes("provider-files") ? "may exclude" : "excludes";
+        push(
+          "headroom",
+          "fail",
+          `Headroom daemon ${String(state.headroomPid)} was started with an allowlist that ${certainty} the serving front door's direct origin ${origin}, so it refuses every request a provider launch sends back through the door. Its supervisor restarts it once no launch is registered against it; \`agent-shim headroom status\` lists the registered launches, and \`--no-headroom\` launches are unaffected.`,
+          String(state.headroomPid)
+        );
+      }
       if (state.lastError !== void 0 && supervisorAlive) {
         push("headroom", "warn", `Headroom recorded a previous error: ${state.lastError}`);
       }
@@ -13308,6 +13481,10 @@ function runDoctor(params) {
       }
     }
   }
+  if (params.frontDoor !== void 0) {
+    const validated3 = params.frontDoor.state.raw === void 0 ? void 0 : validateJson(FrontDoorStateSchema, params.frontDoor.state);
+    pushFrontDoor(push, params.frontDoor.supervisors, validated3?.ok === true ? validated3.data.supervisorPid : void 0);
+  }
   if (params.activeIdentity.raw === void 0) {
     push("active-identity", "pass", "No active identity set.");
   } else {
@@ -13337,6 +13514,7 @@ var SECTION_TITLES = {
   "directory-rules": "Directory rules",
   "global-config": "Global config",
   headroom: "Headroom daemon",
+  frontdoor: "Front door",
   "categories-local": "categories.local.json",
   "active-identity": "Active identity"
 };
@@ -13354,6 +13532,7 @@ var SECTION_ORDER = [
   "directory-rules",
   "global-config",
   "headroom",
+  "frontdoor",
   "categories-local",
   "active-identity"
 ];
@@ -13431,6 +13610,9 @@ function collectDoctorReport(params) {
     shimState.targetPath,
     realpathOrSelf
   );
+  const uid = process.getuid?.();
+  const allowlistInputs = currentHeadroomAllowlistInputs(realFarmFs, paths);
+  const servingHeadroom = resolveServingHeadroomState(realFarmFs, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, realIsProcessRunning);
   const report = runDoctor({
     env: params.env,
     credentialCache: realCredentialCacheEnv(paths),
@@ -13469,8 +13651,13 @@ function collectDoctorReport(params) {
         const statePath = resolved?.path ?? paths.headroomStateFile;
         return { path: statePath, raw: realFarmFs.readFileUtf8(statePath) };
       })(),
-      isRunning: realIsProcessRunning
-    }
+      isRunning: realIsProcessRunning,
+      allowlist: {
+        driftInputs: diagnoseAllowlistDrift({ recordedHash: servingHeadroom?.state.allowlistHash, ...allowlistInputs }),
+        frontDoorOrigin: allowlistInputs.frontDoorOrigin
+      }
+    },
+    ...uid === void 0 ? {} : { frontDoor: { state: { path: paths.frontdoorStateFile, raw: realFsPort.readFileUtf8(paths.frontdoorStateFile) }, supervisors: listFrontDoorSupervisors(realRunPort, uid) } }
   });
   return report;
 }
@@ -13745,7 +13932,8 @@ var IdentityValueSchema = import_zod22.z.strictObject({
   name: import_zod22.z.string(),
   defaultConfigProfile: import_zod22.z.string().optional(),
   allowAmbientCredential: import_zod22.z.boolean(),
-  credential: CredentialSummarySchema2.optional()
+  credential: CredentialSummarySchema2.optional(),
+  anchors: import_zod22.z.array(AnchorSchema).optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
 var ProviderValueSchema = import_zod22.z.strictObject({
@@ -13763,7 +13951,9 @@ var ConfigIdentitySetInputSchema = import_zod22.z.strictObject({
   name: import_zod22.z.string().min(1),
   defaultConfigProfile: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional(),
   allowAmbientCredential: import_zod22.z.boolean().optional(),
-  credential: import_zod22.z.union([import_zod22.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional()
+  credential: import_zod22.z.union([import_zod22.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
+  /** `false` removes the anchors; a list replaces them. */
+  anchors: import_zod22.z.union([import_zod22.z.literal(false), import_zod22.z.array(AnchorSchema).min(1)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
 var ConfigIdentityRemoveInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
@@ -13884,7 +14074,8 @@ function identityValue(name, paths) {
     name: identity.name,
     ...identity.defaultConfigProfile === void 0 ? {} : { defaultConfigProfile: identity.defaultConfigProfile },
     allowAmbientCredential: identity.allowAmbientCredential,
-    ...identity.credential === void 0 ? {} : { credential: summariseCredential(identity.credential) }
+    ...identity.credential === void 0 ? {} : { credential: summariseCredential(identity.credential) },
+    ...identity.anchors === void 0 ? {} : { anchors: identity.anchors }
   };
 }
 function providerValue(name, provider) {
@@ -13915,9 +14106,9 @@ function createConfigApiRouter(deps) {
             return { action: "created", kind: "identity", name: input.name, value: identityValue(input.name, paths) };
           })
         ),
-        set: route("/rest/config/identity/set", "Update an identity's default profile, ambient-credential setting or credential").input(ConfigIdentitySetInputSchema).output(ConfigIdentitySetOutputSchema).handler(
+        set: route("/rest/config/identity/set", "Update an identity's default profile, ambient-credential setting, credential or anchors").input(ConfigIdentitySetInputSchema).output(ConfigIdentitySetOutputSchema).handler(
           ({ input }) => guarded(() => {
-            requireChange(input.defaultConfigProfile !== void 0 || input.allowAmbientCredential !== void 0 || input.credential !== void 0, "defaultConfigProfile, allowAmbientCredential or credential");
+            requireChange(input.defaultConfigProfile !== void 0 || input.allowAmbientCredential !== void 0 || input.credential !== void 0 || input.anchors !== void 0, "defaultConfigProfile, allowAmbientCredential, credential or anchors");
             if (!identityExists(paths, input.name)) {
               throw new IdentityNotFoundError(input.name);
             }
@@ -13942,6 +14133,9 @@ function createConfigApiRouter(deps) {
               };
               setIdentityCredential(paths, input.name, change);
             }
+            if (input.anchors !== void 0) {
+              setIdentityAnchors(paths, input.name, input.anchors === false ? void 0 : input.anchors);
+            }
             return { action: "updated", kind: "identity", name: input.name, value: identityValue(input.name, paths) };
           })
         ),
@@ -14172,7 +14366,9 @@ var DoorHealthEventSchema = import_zod23.z.discriminatedUnion("kind", [
   import_zod23.z.strictObject({ kind: import_zod23.z.literal("generation"), pid: import_zod23.z.number().int().positive(), providerPort: import_zod23.z.number().int().positive(), connectPort: import_zod23.z.number().int().positive(), directPort: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
   import_zod23.z.strictObject({ kind: import_zod23.z.literal("listenerFailed"), pid: import_zod23.z.number().int().positive(), listener: import_zod23.z.enum(["provider", "connect", "direct"]), message: import_zod23.z.string(), observedAt: import_zod23.z.number() }),
   import_zod23.z.strictObject({ kind: import_zod23.z.literal("binaryTurnover"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
-  import_zod23.z.strictObject({ kind: import_zod23.z.literal("idleShutdown"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() })
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("idleShutdown"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("superseded"), pid: import_zod23.z.number().int().positive(), ownerPid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("drained"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() })
 ]);
 var QuotaExpiringEventSchema = import_zod23.z.strictObject({
   identity: import_zod23.z.string().min(1),
@@ -14669,6 +14865,12 @@ function createDoorHealthPublisher(hub, now, pid) {
     },
     binaryTurnover: () => {
       publisher.publish({ kind: "binaryTurnover", pid, observedAt: now() });
+    },
+    superseded: (ownerPid) => {
+      publisher.publish({ kind: "superseded", pid, ownerPid, observedAt: now() });
+    },
+    drained: () => {
+      publisher.publish({ kind: "drained", pid, observedAt: now() });
     }
   };
 }