claude-use 6.2.0 → 6.2.1

package/dist/cli.cjs

@@ -55390,7 +55390,7 @@ var HeadroomStateSchema = external_exports.strictObject({
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
   lastError: external_exports.string().optional()
 });
-var HeadroomSessionSchema = external_exports.strictObject({ pid: external_exports.number().int().positive(), startedAt: external_exports.number() });
+var HeadroomSessionSchema = external_exports.strictObject({ pid: external_exports.number().int().positive(), startedAt: external_exports.number(), supervisorPid: external_exports.number().int().positive() });
 var HeadroomLockSchema = external_exports.strictObject({ pid: external_exports.number().int().positive(), at: external_exports.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
@@ -55470,6 +55470,9 @@ function listSessions(fs16, sessionsDir) {
   }
   return sessions.sort((a2, b) => a2.pid - b.pid);
 }
+function sessionsForSupervisor(fs16, sessionsDir, supervisorPid) {
+  return listSessions(fs16, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+}
 function pruneDeadSessions(fs16, sessionsDir, isRunning) {
   const removed = [];
   for (const session of listSessions(fs16, sessionsDir)) {
@@ -55506,7 +55509,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) {
@@ -60994,7 +60997,7 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "6.2.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>",
@@ -68074,15 +68077,28 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   const { fs: fs16, paths } = ports;
   let config2 = initialConfig;
   const previousState = readHeadroomState(fs16, 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(fs16, paths.headroomStateFile)?.supervisorPid;
+    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
+  };
+  const writeOwnState = (state) => {
+    if (!ownsState()) {
+      return false;
+    }
+    writeHeadroomState(fs16, paths.headroomStateFile, state);
+    return true;
+  };
   const fail = (message) => {
-    writeHeadroomState(fs16, paths.headroomStateFile, {
-      lastError: message,
-      ...sticky()
-    });
-    fs16.removeRecursive(paths.headroomLockFile);
+    if (writeOwnState({ lastError: message, ...sticky() })) {
+      fs16.removeRecursive(paths.headroomLockFile);
+    }
     ports.log(`claude-use headroom supervisor: ${message}`);
     return 1;
   };
@@ -68105,7 +68121,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
   }
   const version2 = ports.headroomVersion() ?? "unknown";
-  writeHeadroomState(fs16, paths.headroomStateFile, { supervisorPid: ports.ownPid, version: version2, installedSource, ...sticky() });
+  writeOwnState({ supervisorPid: ports.ownPid, version: version2, 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)) {
@@ -68117,6 +68133,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) {
@@ -68128,6 +68145,11 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs16, 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) {
@@ -68135,7 +68157,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         headroomPid = void 0;
         runningHash = void 0;
         runningSettingsHash = void 0;
-        writeHeadroomState(fs16, paths.headroomStateFile, {
+        writeOwnState({
           supervisorPid: ports.ownPid,
           version: version2,
           installedSource,
@@ -68163,7 +68185,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(fs16, paths.headroomStateFile, {
+        const recorded = writeOwnState({
           supervisorPid: ports.ownPid,
           headroomPid: pid,
           port,
@@ -68173,7 +68195,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           installedSource: config2.source,
           ...sticky()
         });
-        fs16.removeRecursive(paths.headroomLockFile);
+        if (recorded) {
+          fs16.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 {
@@ -68187,7 +68211,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config2.source) {
-        if (listSessions(fs16, paths.headroomSessionsDir).length === 0) {
+        if (sessionsForSupervisor(fs16, 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;
@@ -68196,7 +68220,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = listSessions(fs16, paths.headroomSessionsDir);
+      const sessions = sessionsForSupervisor(fs16, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -68205,7 +68229,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `claude-use headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
-          writeHeadroomState(fs16, paths.headroomStateFile, {
+          writeOwnState({
             version: version2,
             ...sticky()
           });
@@ -68283,7 +68307,9 @@ function formatHeadroomStatus(status) {
   if (status.sessions.length === 0) {
     lines.push("sessions: none");
   } else {
-    const pids = status.sessions.map((session) => `${String(session.pid)}${session.alive ? "" : " (dead)"}`);
+    const pids = status.sessions.map(
+      (session) => `${String(session.pid)}${session.alive ? "" : " (dead)"}` + (session.supervisorPid === status.state.supervisorPid ? "" : ` on superseded supervisor ${String(session.supervisorPid)}`)
+    );
     lines.push(`sessions: ${String(status.sessions.length)} registered (${pids.join(", ")})`);
   }
   if (status.state.lastError !== void 0) {

package/dist/index.cjs

@@ -2811,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() === "") {
@@ -2891,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)) {
@@ -3190,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) {
@@ -3327,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;
   };
@@ -3358,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)) {
@@ -3370,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) {
@@ -3381,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) {
@@ -3388,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,
@@ -3416,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,
@@ -3426,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 {
@@ -3440,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;
@@ -3449,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;
@@ -3458,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

@@ -2737,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() === "") {
@@ -2817,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)) {
@@ -3116,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) {
@@ -3253,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;
   };
@@ -3284,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)) {
@@ -3296,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) {
@@ -3307,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) {
@@ -3314,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,
@@ -3342,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,
@@ -3352,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 {
@@ -3366,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;
@@ -3375,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;
@@ -3384,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "6.2.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>",