claude-use 9.12.0 → 9.13.0

package/dist/index.cjs

@@ -2595,7 +2595,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 +2623,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 +2663,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.12.0",
+      version: "9.13.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 +2766,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 +3393,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);
@@ -3427,6 +3463,10 @@ function realIsProcessZombie(pid) {
 function realIsProcessRunning(pid) {
   return realIsProcessAlive(pid) && !realIsProcessZombie(pid);
 }
+function realIsFrontDoorSupervisor(pid) {
+  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;
 }
@@ -3636,6 +3676,7 @@ var init_realPorts = __esm({
     import_node_sea = require("node:sea");
     init_load();
     init_versionDiscovery();
+    init_supervisorProcesses();
     init_ensure();
     init_supervisor();
     init_state2();
@@ -4671,7 +4712,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] } };
   }
@@ -4786,7 +4827,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;
@@ -6166,32 +6208,50 @@ function ensureFrontDoor(params) {
   let replaced = false;
   const distrusted = /* @__PURE__ */ new Set();
   let lastRejection;
+  const verifyWithRetry = (port) => {
+    let verdict = ports.verifyListener(port);
+    for (let attempt = 1; !verdict.ok && attempt < FRONTDOOR_PROBE_ATTEMPTS; attempt += 1) {
+      ports.sleep(FRONTDOOR_LAUNCHER_POLL_MS);
+      verdict = ports.verifyListener(port);
+    }
+    return verdict;
+  };
+  const stopAndAwaitExit = (supervisorPid, failure) => {
+    ports.stopSupervisor(supervisorPid);
+    while (ports.isRunning(supervisorPid)) {
+      if (ports.now() >= deadline) {
+        throw new FrontDoorStartError(`${failure}. Daemon log: ${paths.frontdoorLogPath}`);
+      }
+      ports.sleep(FRONTDOOR_LAUNCHER_POLL_MS);
+    }
+  };
   for (; ; ) {
     const state = readFrontDoorState(ports.fs, paths.frontdoorStateFile);
     const supervisorPid = state?.supervisorPid;
     if (supervisorPid !== void 0 && !distrusted.has(supervisorPid) && ports.isRunning(supervisorPid)) {
       if (state?.port !== void 0 && state.connectPort !== void 0) {
-        const verdict = ports.verifyListener(state.port);
+        const verdict = verifyWithRetry(state.port);
         if (verdict.ok && !replaced && !spawned && (params.replace === true || (state.protocol ?? 0) < FRONT_DOOR_PROTOCOL)) {
-          ports.stopSupervisor(supervisorPid);
-          while (ports.isRunning(supervisorPid)) {
-            if (ports.now() >= deadline) {
-              throw new FrontDoorStartError(`the front door (pid ${String(supervisorPid)}, protocol ${String(state.protocol ?? 0)}; this launcher speaks protocol ${String(FRONT_DOOR_PROTOCOL)}) was asked to be replaced and did not exit. Daemon log: ${paths.frontdoorLogPath}`);
-            }
-            ports.sleep(FRONTDOOR_LAUNCHER_POLL_MS);
-          }
+          stopAndAwaitExit(
+            supervisorPid,
+            `the front door (pid ${String(supervisorPid)}, protocol ${String(state.protocol ?? 0)}; this launcher speaks protocol ${String(FRONT_DOOR_PROTOCOL)}) was asked to be replaced and did not exit`
+          );
           replaced = true;
           continue;
         }
         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}`;
         if (spawned) {
           throw new FrontDoorStartError(`${lastRejection}; refusing to send this session's credentials to it. Daemon log: ${paths.frontdoorLogPath}`);
         }
+        if (ports.isFrontDoorSupervisor(supervisorPid)) {
+          stopAndAwaitExit(supervisorPid, `the front door (pid ${String(supervisorPid)}) stopped answering and did not exit when asked to`);
+          continue;
+        }
         distrusted.add(supervisorPid);
         continue;
       }
@@ -6222,7 +6282,7 @@ function ensureFrontDoor(params) {
     ports.sleep(FRONTDOOR_LAUNCHER_POLL_MS);
   }
 }
-var import_node_crypto9, FRONTDOOR_START_TIMEOUT_MS, FRONTDOOR_LAUNCHER_POLL_MS, FrontDoorStartError;
+var import_node_crypto9, FRONTDOOR_START_TIMEOUT_MS, FRONTDOOR_LAUNCHER_POLL_MS, FRONTDOOR_PROBE_ATTEMPTS, FrontDoorStartError;
 var init_ensure2 = __esm({
   "src/frontdoor/ensure.ts"() {
     "use strict";
@@ -6232,6 +6292,7 @@ var init_ensure2 = __esm({
     init_state();
     FRONTDOOR_START_TIMEOUT_MS = 3e4;
     FRONTDOOR_LAUNCHER_POLL_MS = 100;
+    FRONTDOOR_PROBE_ATTEMPTS = 3;
     FrontDoorStartError = class extends CliError {
       constructor(message) {
         super(message);
@@ -6715,7 +6776,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);
@@ -7418,6 +7484,7 @@ function realEnsurePorts(paths, spawnDaemon) {
     now: () => Date.now(),
     sleep: realSleepSync,
     spawnSupervisor: (layout) => spawnDaemon(layout, "__frontdoor-supervisor", layout.frontdoorLogPath),
+    isFrontDoorSupervisor: realIsFrontDoorSupervisor,
     stopSupervisor: (pid) => {
       process.kill(pid, "SIGTERM");
     },
@@ -8676,16 +8743,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 (; ; ) {
@@ -8698,7 +8776,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();
@@ -12852,7 +12951,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();
@@ -12875,7 +13022,8 @@ var DOCTOR_SECTIONS = [
   "global-config",
   "categories-local",
   "active-identity",
-  "headroom"
+  "headroom",
+  "frontdoor"
 ];
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
@@ -13271,6 +13419,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}`);
       }
@@ -13283,6 +13442,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 {
@@ -13312,6 +13475,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"
 };
@@ -13329,6 +13493,7 @@ var SECTION_ORDER = [
   "directory-rules",
   "global-config",
   "headroom",
+  "frontdoor",
   "categories-local",
   "active-identity"
 ];
@@ -13406,6 +13571,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),
@@ -13444,8 +13612,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;
 }
@@ -14147,7 +14320,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),
@@ -14644,6 +14819,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() });
     }
   };
 }