claude-use 6.1.0 → 6.2.1

package/dist/index.cjs

@@ -215,10 +215,18 @@ var ConfigProfileSchema = import_zod.z.strictObject({
   entries: EntriesSchema.optional(),
   launch: LaunchSchema.optional()
 });
+var POOL_SELECTOR_PREFIX = "pool:";
+var POOL_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._-]*";
+var IDENTITY_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._@-]*";
+var PoolNameSchema = import_zod.z.string().min(1).regex(new RegExp(`^${POOL_NAME_PATTERN}$`));
+var IdentitySelectorSchema = import_zod.z.string().min(1).regex(new RegExp(`^(${POOL_SELECTOR_PREFIX}${POOL_NAME_PATTERN}|${IDENTITY_NAME_PATTERN})$`));
+var PoolSchema = import_zod.z.strictObject({
+  identities: import_zod.z.array(import_zod.z.string().min(1).regex(new RegExp(`^${IDENTITY_NAME_PATTERN}$`))).min(1).refine((names) => new Set(names).size === names.length, { message: "pool members must be unique" })
+});
 var DirectoryRuleSchema = ConfigProfileSchema.omit({ description: true }).extend({
   path: import_zod.z.string().min(1),
   configProfile: import_zod.z.string().min(1).optional(),
-  identity: import_zod.z.string().min(1).optional(),
+  identity: IdentitySelectorSchema.optional(),
   when: WhenSchema.optional()
 });
 var DirectoryRulesSchema = import_zod.z.strictObject({
@@ -227,7 +235,7 @@ var DirectoryRulesSchema = import_zod.z.strictObject({
 });
 var PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).extend({
   configProfile: import_zod.z.string().min(1).optional(),
-  identity: import_zod.z.string().min(1).optional(),
+  identity: IdentitySelectorSchema.optional(),
   when: WhenSchema.optional()
 });
 var HEADROOM_MODES = ["cache", "token"];
@@ -275,7 +283,8 @@ var GlobalConfigSchema = import_zod.z.strictObject({
   entries: EntriesSchema.optional(),
   launch: LaunchSchema.optional(),
   headroom: HeadroomGlobalConfigSchema.optional(),
-  frontdoor: FrontDoorGlobalConfigSchema.optional()
+  frontdoor: FrontDoorGlobalConfigSchema.optional(),
+  pools: import_zod.z.record(PoolNameSchema, PoolSchema).optional()
 });
 var IdentitySchema = import_zod.z.strictObject({
   $schema: import_zod.z.string().optional(),
@@ -2802,7 +2811,7 @@ var HeadroomStateSchema = import_zod4.z.strictObject({
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
   lastError: import_zod4.z.string().optional()
 });
-var HeadroomSessionSchema = import_zod4.z.strictObject({ pid: import_zod4.z.number().int().positive(), startedAt: import_zod4.z.number() });
+var HeadroomSessionSchema = import_zod4.z.strictObject({ pid: import_zod4.z.number().int().positive(), startedAt: import_zod4.z.number(), supervisorPid: import_zod4.z.number().int().positive() });
 var HeadroomLockSchema = import_zod4.z.strictObject({ pid: import_zod4.z.number().int().positive(), at: import_zod4.z.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
@@ -2882,6 +2891,9 @@ function listSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
+function sessionsForSupervisor(fs2, sessionsDir, supervisorPid) {
+  return listSessions(fs2, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+}
 function pruneDeadSessions(fs2, sessionsDir, isRunning) {
   const removed = [];
   for (const session of listSessions(fs2, sessionsDir)) {
@@ -3181,7 +3193,7 @@ function ensureHeadroom(params) {
     if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
       const daemonUp = state.port !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
       if (daemonUp && state.port !== void 0) {
-        writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now() });
+        writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
         return { port: state.port };
       }
       if (state.lastError !== void 0) {
@@ -3318,15 +3330,28 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs2, paths } = ports;
   let config = initialConfig;
   const previousState = readHeadroomState(fs2, paths.headroomStateFile);
+  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
+    ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
+    return 0;
+  }
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
+  const ownsState = () => {
+    const owner = readHeadroomState(fs2, paths.headroomStateFile)?.supervisorPid;
+    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
+  };
+  const writeOwnState = (state) => {
+    if (!ownsState()) {
+      return false;
+    }
+    writeHeadroomState(fs2, paths.headroomStateFile, state);
+    return true;
+  };
   const fail = (message) => {
-    writeHeadroomState(fs2, paths.headroomStateFile, {
-      lastError: message,
-      ...sticky()
-    });
-    fs2.removeRecursive(paths.headroomLockFile);
+    if (writeOwnState({ lastError: message, ...sticky() })) {
+      fs2.removeRecursive(paths.headroomLockFile);
+    }
     ports.log(`claude-use headroom supervisor: ${message}`);
     return 1;
   };
@@ -3349,7 +3374,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
   }
   const version = ports.headroomVersion() ?? "unknown";
-  writeHeadroomState(fs2, paths.headroomStateFile, { supervisorPid: ports.ownPid, version, installedSource, ...sticky() });
+  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource, ...sticky() });
   ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
   if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
@@ -3361,6 +3386,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let runningSettingsHash;
   let consecutiveFailures = 0;
   let idleSince;
+  let superseded = false;
   let ticks = 0;
   for (; ; ) {
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
@@ -3372,6 +3398,11 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
+    const ownsNow = ownsState();
+    if (!ownsNow && !superseded) {
+      ports.log("claude-use headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
+    }
+    superseded = !ownsNow;
     const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
     if (headroomPid === void 0 || crashed) {
       if (crashed) {
@@ -3379,7 +3410,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         headroomPid = void 0;
         runningHash = void 0;
         runningSettingsHash = void 0;
-        writeHeadroomState(fs2, paths.headroomStateFile, {
+        writeOwnState({
           supervisorPid: ports.ownPid,
           version,
           installedSource,
@@ -3407,7 +3438,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `claude-use headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
           );
         }
-        writeHeadroomState(fs2, paths.headroomStateFile, {
+        const recorded = writeOwnState({
           supervisorPid: ports.ownPid,
           headroomPid: pid,
           port,
@@ -3417,7 +3448,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           installedSource: config.source,
           ...sticky()
         });
-        fs2.removeRecursive(paths.headroomLockFile);
+        if (recorded) {
+          fs2.removeRecursive(paths.headroomLockFile);
+        }
         idleSince = void 0;
         ports.log(`claude-use headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
       } else {
@@ -3431,7 +3464,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (listSessions(fs2, paths.headroomSessionsDir).length === 0) {
+        if (sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid).length === 0) {
           ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
@@ -3440,7 +3473,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = listSessions(fs2, paths.headroomSessionsDir);
+      const sessions = sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -3449,7 +3482,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `claude-use headroom supervisor: no sessions for ${String(config.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
-          writeHeadroomState(fs2, paths.headroomStateFile, {
+          writeOwnState({
             version,
             ...sticky()
           });

package/dist/index.mjs

@@ -141,10 +141,18 @@ var ConfigProfileSchema = z.strictObject({
   entries: EntriesSchema.optional(),
   launch: LaunchSchema.optional()
 });
+var POOL_SELECTOR_PREFIX = "pool:";
+var POOL_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._-]*";
+var IDENTITY_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._@-]*";
+var PoolNameSchema = z.string().min(1).regex(new RegExp(`^${POOL_NAME_PATTERN}$`));
+var IdentitySelectorSchema = z.string().min(1).regex(new RegExp(`^(${POOL_SELECTOR_PREFIX}${POOL_NAME_PATTERN}|${IDENTITY_NAME_PATTERN})$`));
+var PoolSchema = z.strictObject({
+  identities: z.array(z.string().min(1).regex(new RegExp(`^${IDENTITY_NAME_PATTERN}$`))).min(1).refine((names) => new Set(names).size === names.length, { message: "pool members must be unique" })
+});
 var DirectoryRuleSchema = ConfigProfileSchema.omit({ description: true }).extend({
   path: z.string().min(1),
   configProfile: z.string().min(1).optional(),
-  identity: z.string().min(1).optional(),
+  identity: IdentitySelectorSchema.optional(),
   when: WhenSchema.optional()
 });
 var DirectoryRulesSchema = z.strictObject({
@@ -153,7 +161,7 @@ var DirectoryRulesSchema = z.strictObject({
 });
 var PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).extend({
   configProfile: z.string().min(1).optional(),
-  identity: z.string().min(1).optional(),
+  identity: IdentitySelectorSchema.optional(),
   when: WhenSchema.optional()
 });
 var HEADROOM_MODES = ["cache", "token"];
@@ -201,7 +209,8 @@ var GlobalConfigSchema = z.strictObject({
   entries: EntriesSchema.optional(),
   launch: LaunchSchema.optional(),
   headroom: HeadroomGlobalConfigSchema.optional(),
-  frontdoor: FrontDoorGlobalConfigSchema.optional()
+  frontdoor: FrontDoorGlobalConfigSchema.optional(),
+  pools: z.record(PoolNameSchema, PoolSchema).optional()
 });
 var IdentitySchema = z.strictObject({
   $schema: z.string().optional(),
@@ -2728,7 +2737,7 @@ var HeadroomStateSchema = z4.strictObject({
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
   lastError: z4.string().optional()
 });
-var HeadroomSessionSchema = z4.strictObject({ pid: z4.number().int().positive(), startedAt: z4.number() });
+var HeadroomSessionSchema = z4.strictObject({ pid: z4.number().int().positive(), startedAt: z4.number(), supervisorPid: z4.number().int().positive() });
 var HeadroomLockSchema = z4.strictObject({ pid: z4.number().int().positive(), at: z4.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
@@ -2808,6 +2817,9 @@ function listSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
+function sessionsForSupervisor(fs2, sessionsDir, supervisorPid) {
+  return listSessions(fs2, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+}
 function pruneDeadSessions(fs2, sessionsDir, isRunning) {
   const removed = [];
   for (const session of listSessions(fs2, sessionsDir)) {
@@ -3107,7 +3119,7 @@ function ensureHeadroom(params) {
     if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
       const daemonUp = state.port !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
       if (daemonUp && state.port !== void 0) {
-        writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now() });
+        writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
         return { port: state.port };
       }
       if (state.lastError !== void 0) {
@@ -3244,15 +3256,28 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs2, paths } = ports;
   let config = initialConfig;
   const previousState = readHeadroomState(fs2, paths.headroomStateFile);
+  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
+    ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
+    return 0;
+  }
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
+  const ownsState = () => {
+    const owner = readHeadroomState(fs2, paths.headroomStateFile)?.supervisorPid;
+    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
+  };
+  const writeOwnState = (state) => {
+    if (!ownsState()) {
+      return false;
+    }
+    writeHeadroomState(fs2, paths.headroomStateFile, state);
+    return true;
+  };
   const fail = (message) => {
-    writeHeadroomState(fs2, paths.headroomStateFile, {
-      lastError: message,
-      ...sticky()
-    });
-    fs2.removeRecursive(paths.headroomLockFile);
+    if (writeOwnState({ lastError: message, ...sticky() })) {
+      fs2.removeRecursive(paths.headroomLockFile);
+    }
     ports.log(`claude-use headroom supervisor: ${message}`);
     return 1;
   };
@@ -3275,7 +3300,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
   }
   const version = ports.headroomVersion() ?? "unknown";
-  writeHeadroomState(fs2, paths.headroomStateFile, { supervisorPid: ports.ownPid, version, installedSource, ...sticky() });
+  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource, ...sticky() });
   ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
   if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
@@ -3287,6 +3312,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let runningSettingsHash;
   let consecutiveFailures = 0;
   let idleSince;
+  let superseded = false;
   let ticks = 0;
   for (; ; ) {
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
@@ -3298,6 +3324,11 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
+    const ownsNow = ownsState();
+    if (!ownsNow && !superseded) {
+      ports.log("claude-use headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
+    }
+    superseded = !ownsNow;
     const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
     if (headroomPid === void 0 || crashed) {
       if (crashed) {
@@ -3305,7 +3336,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         headroomPid = void 0;
         runningHash = void 0;
         runningSettingsHash = void 0;
-        writeHeadroomState(fs2, paths.headroomStateFile, {
+        writeOwnState({
           supervisorPid: ports.ownPid,
           version,
           installedSource,
@@ -3333,7 +3364,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `claude-use headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
           );
         }
-        writeHeadroomState(fs2, paths.headroomStateFile, {
+        const recorded = writeOwnState({
           supervisorPid: ports.ownPid,
           headroomPid: pid,
           port,
@@ -3343,7 +3374,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           installedSource: config.source,
           ...sticky()
         });
-        fs2.removeRecursive(paths.headroomLockFile);
+        if (recorded) {
+          fs2.removeRecursive(paths.headroomLockFile);
+        }
         idleSince = void 0;
         ports.log(`claude-use headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
       } else {
@@ -3357,7 +3390,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (listSessions(fs2, paths.headroomSessionsDir).length === 0) {
+        if (sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid).length === 0) {
           ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
@@ -3366,7 +3399,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = listSessions(fs2, paths.headroomSessionsDir);
+      const sessions = sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -3375,7 +3408,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `claude-use headroom supervisor: no sessions for ${String(config.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
-          writeHeadroomState(fs2, paths.headroomStateFile, {
+          writeOwnState({
             version,
             ...sticky()
           });

package/dist/types/config/schema.d.ts

@@ -422,6 +422,15 @@ export declare const ConfigProfileSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ConfigProfile = z.infer<typeof ConfigProfileSchema>;
+/** The prefix that turns a pool name into an identity selector. `:` is outside an identity name's character set, so a selector can never be mistaken for an identity. */
+export declare const POOL_SELECTOR_PREFIX = "pool:";
+/** A pool's own name: the identity alphabet minus `@`, since a pool is never an email address. */
+export declare const PoolNameSchema: z.ZodString;
+/** A named, explicit set of identities to choose among at launch. Never implicit: a pool lists its members, so an identity that bills a client is only ever picked when someone put it there. */
+declare const PoolSchema: z.ZodObject<{
+    identities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type Pool = z.infer<typeof PoolSchema>;
 /** One directory rule in `~/.claude-use/directory-rules.json`, scoped to an explicit absolute (or `~`-rooted) path. */
 export declare const DirectoryRuleSchema: z.ZodObject<{
     entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
@@ -657,6 +666,9 @@ export declare const GlobalConfigSchema: z.ZodObject<{
     frontdoor: z.ZodOptional<z.ZodObject<{
         idleShutdownMinutes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    pools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        identities: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type GlobalConfig = z.infer<typeof GlobalConfigSchema>;
 /**

package/dist/types/headroom/state.d.ts

@@ -20,10 +20,13 @@ export declare const HeadroomStateSchema: z.ZodObject<{
 export type HeadroomState = z.infer<typeof HeadroomStateSchema>;
 /** The filesystem operations headroom coordination needs: the same shape as `FarmFs`, injected so every decision over state, sessions, and the start lock runs against an in-memory fake in tests. */
 export type HeadroomFs = Pick<FarmFs, "mkdirp" | "mkdirPrivate" | "readFileUtf8" | "writeFileUtf8" | "writeFilePrivate" | "writeFileExclusive" | "readdir" | "removeRecursive">;
-/** The record held in one session-registry file. */
+/**
+ * The record held in one session-registry file. `supervisorPid` names the supervisor whose daemon the launch connected to: several supervisors can be alive at once (a superseded one keeps serving the sessions it already has), and each must judge idle shutdown and drift restarts by its own sessions only, or none would ever retire.
+ */
 declare const HeadroomSessionSchema: z.ZodObject<{
     pid: z.ZodNumber;
     startedAt: z.ZodNumber;
+    supervisorPid: z.ZodNumber;
 }, z.core.$strict>;
 export type HeadroomSession = z.infer<typeof HeadroomSessionSchema>;
 /** The exclusive-create start lock's recorded holder. */
@@ -63,6 +66,8 @@ export declare function writeSession(fs: HeadroomFs, sessionsDir: string, sessio
 export declare function removeSession(fs: HeadroomFs, sessionsDir: string, pid: number): void;
 /** Every registry entry on disk, unreadable files skipped, sorted by pid: what `headroom status` prints and what the supervisor's idle and drift decisions read. */
 export declare function listSessions(fs: HeadroomFs, sessionsDir: string): readonly HeadroomSession[];
+/** The registry entries recorded against one supervisor: the sessions whose daemon that supervisor is responsible for keeping up. */
+export declare function sessionsForSupervisor(fs: HeadroomFs, sessionsDir: string, supervisorPid: number): readonly HeadroomSession[];
 /**
  * Removes every registry entry whose pid is no longer running: a launcher that died without releasing its entry must not keep the daemon awake or block a drift restart forever. The predicate must be zombie-aware (see `realIsProcessRunning`): a launcher that exited but was never reaped still answers signal 0 as alive, which would keep its session registered indefinitely.
  */

package/dist/types/paths.d.ts

@@ -58,6 +58,8 @@ export interface LayoutPaths {
     readonly usageLogDir: string;
     /** Directory of the latest-state snapshots, one `<identity>.json` per identity: the stable file other tools read. */
     readonly usageSnapshotsDir: string;
+    /** The last identity picked from a pool for each directory, so a conversation stays on the account whose prompt cache is warm. */
+    readonly usagePicksFile: string;
 }
 /**
  * Resolves the current CLAUDE_USE_HOME root: the environment variable when set to a non-empty string, otherwise `~/.claude-use`. An empty string counts as unset, consistent with how this project treats empty-string environment variables elsewhere (see the ambient-credential guard).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "6.1.0",
+  "version": "6.2.1",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",