agl 40.5.0 → 40.6.0

package/ts_authswitch/classes.authorityclient.ts

@@ -14,7 +14,8 @@ import type {
   IReq_AuthSwitchSetAccountSpendLimit,
   IReq_AuthSwitchRecheckUsage, IReq_AuthSwitchMoveClaudeHomeIn, IReq_AuthSwitchMoveClaudeHomeOut,
   IReq_AuthSwitchRegisterClaudeHome, IReq_AuthSwitchResolveClaudeHome, IReq_AuthSwitchUnregisterClaudeHome,
-  IReq_AuthSwitchCancelClaudeSignIn, IReq_AuthSwitchGetClaudeSignIn, IReq_AuthSwitchStartClaudeSignIn,
+  IAuthSwitchClaudeSignInOperation, IReq_AuthSwitchCancelClaudeSignIn, IReq_AuthSwitchGetClaudeSignIn,
+  IReq_AuthSwitchStartClaudeSignIn,
   IReq_AuthSwitchCodexNativeHandoff, IReq_AuthSwitchCodexNativeHandoffs, IReq_AuthSwitchSwitchCodexNative,
   IReq_AuthSwitchReleaseCodexNative,
 } from './authority-contract.js';
@@ -137,6 +138,17 @@ const assertCurrentSnapshot = (snapshot: IAuthSwitchSnapshot): IAuthSwitchSnapsh
   return snapshot;
 };
 
+/**
+ * A Claude sign-in carries every member of this release's contract; one without `heldBy`, which names the processes
+ * holding a sign-in, comes from a daemon older than this client.
+ */
+const assertCurrentClaudeSignIn = (operation: IAuthSwitchClaudeSignInOperation): IAuthSwitchClaudeSignInOperation => {
+  if ((operation as Partial<IAuthSwitchClaudeSignInOperation>).heldBy === undefined) {
+    throw new AuthSwitchDaemonOutdatedError();
+  }
+  return operation;
+};
+
 /** A snapshot is usable only while state is current; lastVerifiedAt is the last successful daemon proof. */
 export interface IAuthSwitchSubscriptionStatus {
   state: 'current' | 'unavailable' | 'closed';
@@ -628,13 +640,15 @@ export class AuthSwitchClient {
   /** Starts a Claude sign-in; see `IAuthSwitchClaudeSignInOperation`. The same operation id answers the same sign-in. */
   public async startClaudeSignIn(operationId: string,
     signal?: AbortSignal): Promise<IReq_AuthSwitchStartClaudeSignIn['response']['operation']> {
-    return (await this.request<IReq_AuthSwitchStartClaudeSignIn>('authswitch.authority.claude.signin.start',
-      { operationId }, 35_000, false, signal)).operation;
+    return assertCurrentClaudeSignIn((await this.request<IReq_AuthSwitchStartClaudeSignIn>(
+      'authswitch.authority.claude.signin.start', { operationId }, 35_000, false,
+      signal)).operation);
   }
   public async getClaudeSignIn(operationId: string,
     signal?: AbortSignal): Promise<IReq_AuthSwitchGetClaudeSignIn['response']['operation']> {
-    return (await this.request<IReq_AuthSwitchGetClaudeSignIn>('authswitch.authority.claude.signin.operation',
-      { operationId }, 35_000, false, signal)).operation;
+    return assertCurrentClaudeSignIn((await this.request<IReq_AuthSwitchGetClaudeSignIn>(
+      'authswitch.authority.claude.signin.operation', { operationId }, 35_000, false,
+      signal)).operation);
   }
   /**
    * Waits up to `waitMs` for the Claude sign-in to change past `afterRevision`, as `watchOperation` does for a device
@@ -642,13 +656,15 @@ export class AuthSwitchClient {
    */
   public async watchClaudeSignIn(operationId: string, afterRevision: number, waitMs = 30_000,
     signal?: AbortSignal): Promise<IReq_AuthSwitchGetClaudeSignIn['response']['operation']> {
-    return (await this.request<IReq_AuthSwitchGetClaudeSignIn>('authswitch.authority.claude.signin.operation',
-      { operationId, afterRevision, waitMs }, waitMs + 5_000, false, signal)).operation;
+    return assertCurrentClaudeSignIn((await this.request<IReq_AuthSwitchGetClaudeSignIn>(
+      'authswitch.authority.claude.signin.operation', { operationId, afterRevision, waitMs }, waitMs + 5_000, false,
+      signal)).operation);
   }
   public async cancelClaudeSignIn(operationId: string,
     signal?: AbortSignal): Promise<IReq_AuthSwitchCancelClaudeSignIn['response']['operation']> {
-    return (await this.request<IReq_AuthSwitchCancelClaudeSignIn>('authswitch.authority.claude.signin.cancel',
-      { operationId }, 35_000, false, signal)).operation;
+    return assertCurrentClaudeSignIn((await this.request<IReq_AuthSwitchCancelClaudeSignIn>(
+      'authswitch.authority.claude.signin.cancel', { operationId }, 35_000, false,
+      signal)).operation);
   }
   /** Registers a Claude home the caller created for a container; see `IReq_AuthSwitchRegisterClaudeHome`. */
   public async registerClaudeHome(input: Omit<IReq_AuthSwitchRegisterClaudeHome['request'], 'runtime'>,

package/ts_authswitch/classes.claudenative.ts

@@ -189,6 +189,10 @@ export interface IClaudeNativeRunningContext {
   /** The Agent SDK version whose platform package holds its executable, for an Agent SDK binary only. */
   agentSdkVersion?: string;
   env: NodeJS.ProcessEnv | null;
+  /**
+   * Its working directory as its own root sees it; null when that cannot be resolved -- deleted under it, for one -- so
+   * nothing that needs it (a relative home or store, its project settings) can be proven.
+   */
   cwd: string | null;
   hasSettingsOverride: boolean | null;
   /** The selected native home as seen through this process's mount namespace. */
@@ -708,10 +712,24 @@ class ClaudeNativeVersionProbe implements IClaudeNativeVersionProbe {
   }
 }
 
+/**
+ * The working directory `/proc/<pid>/cwd` names, when that path is the very directory the process works in as its own
+ * root sees it; null otherwise, as for a directory deleted under the process, which the link names `<path> (deleted)`.
+ */
+const resolvedProcessCwd = (pid: number, root: string): string | null => {
+  try {
+    const cwd = plugins.fs.readlinkSync(`/proc/${pid}/cwd`);
+    return plugins.path.isAbsolute(cwd) && sameDirectory(directoryIdentity(`/proc/${pid}/cwd`),
+      directoryIdentity(processViewPath(cwd, root))) ? cwd : null;
+  } catch { return null; }
+};
+
 /**
  * Every Claude Code process of this user, the home it selects and the directory of its credential store, resolved
  * through its own mount namespace (`/proc/<pid>/root`), so a process in a container that bind-mounts a home is matched to
- * that home's inode. A live process whose context cannot be read is listed with unknown fields rather than skipped.
+ * that home's inode. A live process whose context cannot be read is listed with unknown fields rather than skipped. A
+ * working directory that cannot be resolved leaves `cwd` unknown and only what depends on it: a home or store the
+ * process names by an absolute path is still resolved under its root, one named by a relative path is not.
  */
 export const scanClaudeRunningContexts = (): readonly IClaudeNativeRunningContext[] => {
   const contexts: IClaudeNativeRunningContext[] = [];
@@ -738,20 +756,18 @@ export const scanClaudeRunningContexts = (): readonly IClaudeNativeRunningContex
       }
       mountNamespace = plugins.fs.readlinkSync(`/proc/${running.pid}/ns/mnt`);
       env = selectorEnvironment(readProcessContext(`/proc/${running.pid}/environ`));
-      cwd = plugins.fs.readlinkSync(`/proc/${running.pid}/cwd`);
       const root = `/proc/${running.pid}/root`;
       processRoot = root;
-      if (!plugins.path.isAbsolute(cwd) || !sameDirectory(
-        directoryIdentity(`/proc/${running.pid}/cwd`),
-        directoryIdentity(processViewPath(cwd, root)))) {
-        throw new Error('Claude process working directory cannot be resolved in its mount namespace.');
-      }
+      cwd = resolvedProcessCwd(running.pid, root);
       // A directory the process names, as it sees it: an absolute path under its own root, a relative one under its cwd.
       const processDirectory = (selected: string | null, name: string): IClaudeNativeDirectoryIdentity => {
         if (!selected) throw new Error(`Claude process ${name} is unknown.`);
         if (plugins.path.isAbsolute(selected) && plugins.path.normalize(selected) !== selected) {
           throw new Error(`Claude process ${name} path is ambiguous.`);
         }
+        if (!plugins.path.isAbsolute(selected) && cwd === null) {
+          throw new Error(`Claude process ${name} is relative to a working directory that cannot be resolved.`);
+        }
         return directoryIdentity(plugins.path.isAbsolute(selected)
           ? processViewPath(selected, root)
           // Preserve the proc magic symlink before `..` is resolved by the target's VFS.

package/ts_authswitch/classes.claudesignin.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
-import { AuthSwitchRefusal, authSwitchClaudeSignInArguments,
-  type IAuthSwitchClaudeSignInOperation } from './authority-contract.js';
+import { AuthSwitchRefusal, authSwitchClaudeSignInArguments, authSwitchClaudeSignInHoldersText,
+  type IAuthSwitchClaudeSignInHolder, type IAuthSwitchClaudeSignInOperation } from './authority-contract.js';
 import type { AuthSwitchGrantImport, IAuthSwitchImportClaudeTokens } from './classes.authorityimport.js';
 import type { IAuthSwitchSecretCodec } from './classes.authoritysecrets.js';
 import { canonicalContainerDirectory, ClaudeContainerHome, discardContainerPair, inspectClaudeContainerDirectory,
@@ -38,6 +38,20 @@ const isUuid = (value: string): boolean => /^[a-f0-9-]{36}$/.test(value);
 const shellWord = (value: string): string => `'${value.replaceAll('\'', '\'\\\'\'')}'`;
 const finished = (state: IAuthSwitchClaudeSignInOperation['state']): boolean =>
   state !== 'pending' && state !== 'committing';
+/**
+ * How much earlier than a sign-in's home a process must have started, by the process table, to be proven older than
+ * it: `ps` names the start to the whole second, cut down, from a boot time the kernel also keeps to the whole second, so
+ * a process may have started up to two seconds after the moment the table names. The rest is room for clock slew.
+ */
+const startedBeforeMarginMs = 5_000;
+const startedBefore = (startedAt: string | null, madeAtMs: number): boolean => {
+  const started = startedAt === null ? Number.NaN : Date.parse(startedAt);
+  return Number.isFinite(started) && started + startedBeforeMarginMs <= madeAtMs;
+};
+const sameHolders = (left: readonly IAuthSwitchClaudeSignInHolder[] | null,
+  right: readonly IAuthSwitchClaudeSignInHolder[] | null): boolean =>
+  left === null || right === null ? left === right : left.length === right.length && left.every((holder, index) =>
+    holder.pid === right[index]!.pid && holder.startedAt === right[index]!.startedAt && holder.reason === right[index]!.reason);
 
 interface IClaudeSignIn {
   operation: IAuthSwitchClaudeSignInOperation;
@@ -51,7 +65,8 @@ interface IClaudeSignIn {
 
 /**
  * Claude sign-ins: Claude Code signs in to a home the daemon made for that one sign-in, and the daemon imports the
- * login it finds there once no Claude Code process runs on the home any more, then removes the home.
+ * login it finds there once no Claude Code process may still run on the home, then removes the home. Until then the
+ * sign-in names the processes that hold it (`heldBy`).
  *
  * The home is the daemon's own, below a directory of its user that no one else can write, and it is touched only by
  * descriptor, as a container home is (`ClaudeContainerHome`): a home replaced by a link cannot redirect a read or the
@@ -103,8 +118,9 @@ export class ClaudeSignInAuthority {
     const directory = plugins.path.join(this.options.directory, operationId);
     const { parent, leaf } = inspectClaudeContainerDirectory(directory, this.owner);
     if (leaf !== null) throw new Error('A Claude sign-in home already exists for this operation.');
-    ClaudeContainerHome.open(directory, parent, { create: true, owner: this.owner }).close();
+    // Read before the home is made, so no process that started after it can seem to have started before it.
     const now = this.now();
+    ClaudeContainerHome.open(directory, parent, { create: true, owner: this.owner }).close();
     const signIn: IClaudeSignIn = {
       operation: { id: operationId, state: 'pending',
         // The credential store is pinned to the home as well: one an inherited CLAUDE_SECURESTORAGE_CONFIG_DIR names
@@ -112,6 +128,7 @@ export class ClaudeSignInAuthority {
         prompt: { flow: 'terminal', directory,
           command: `CLAUDE_CONFIG_DIR=${shellWord(directory)} CLAUDE_SECURESTORAGE_CONFIG_DIR=${shellWord(directory)} `
             + `claude ${authSwitchClaudeSignInArguments.join(' ')}` },
+        heldBy: null,
         result: null, error: null, createdAt: new Date(now).toISOString(), updatedAt: new Date(now).toISOString(),
         expiresAt: new Date(now + signInWindowMs).toISOString(), finishedAt: null, revision: 1 },
       directory, parent, timer: null, commit: null,
@@ -192,14 +209,13 @@ export class ClaudeSignInAuthority {
     }, this.pollIntervalMs);
   }
 
-  /** Looks once for the login: imports it when it is there and no Claude Code runs on the home, else waits on. */
+  /**
+   * Looks once for the login: imports it when it is there and nothing holds it (`holders`), else waits on, keeping in
+   * `heldBy` what holds it. At `expiresAt` it ends instead and imports nothing, saying whether a login had arrived and
+   * what held it.
+   */
   private poll(signIn: IClaudeSignIn): void {
     if (this.closed || signIn.operation.state !== 'pending') return;
-    if (this.now() >= Date.parse(signIn.operation.expiresAt)) {
-      this.end(signIn, 'failed', 'No Claude login arrived within fifteen minutes, so nothing was added. Start a new '
-        + 'sign-in.');
-      return;
-    }
     let read: { pair: IClaudeContainerPair; identity: IClaudeContainerDirectoryIdentity | null } | null = null;
     try {
       const home = ClaudeContainerHome.open(signIn.directory, signIn.parent, { create: false, owner: this.owner });
@@ -213,29 +229,59 @@ export class ClaudeSignInAuthority {
       return;
     }
     const { pair, identity } = read;
-    let ready: boolean;
-    try {
-      // A process whose home or credential store is the sign-in home, or unknown, may still write the login there.
-      ready = pair.credentialRaw !== null && identity !== null && !this.runningContexts().some(context =>
-        context.nativeHomeIdentity === null || context.credentialStoreIdentity === null
-        || sameContainerDirectory(context.nativeHomeIdentity, identity)
-        || sameContainerDirectory(context.credentialStoreIdentity, identity));
-    } catch {
+    let holders: IAuthSwitchClaudeSignInHolder[] | null = null;
+    if (pair.credentialRaw !== null && identity !== null) {
+      try { holders = this.holders(identity, Date.parse(signIn.operation.createdAt)); }
+      catch {
+        discardContainerPair(pair);
+        this.end(signIn, 'failed', 'The authority could not tell whether Claude Code still runs on the sign-in home, '
+          + 'so nothing was added. Start a new sign-in.');
+        return;
+      }
+    }
+    if (this.now() >= Date.parse(signIn.operation.expiresAt)) {
       discardContainerPair(pair);
-      this.end(signIn, 'failed', 'The authority could not tell whether Claude Code still runs on the sign-in home, '
-        + 'so nothing was added. Start a new sign-in.');
+      this.end(signIn, 'failed', holders === null
+        ? 'No Claude login arrived within fifteen minutes, so nothing was added. Start a new sign-in.'
+        : holders.length > 0
+          ? 'A Claude login arrived but was not added: until the sign-in ended, fifteen minutes after it started, these '
+            + `Claude Code processes kept it from being imported: ${authSwitchClaudeSignInHoldersText(holders)}. Start a `
+            + 'new sign-in once they have ended.'
+          : 'A Claude login arrived only as the sign-in ended, fifteen minutes after it started, so it was not added. '
+            + 'Start a new sign-in.');
       return;
     }
-    if (!ready) {
+    if (holders === null || holders.length > 0) {
       discardContainerPair(pair);
+      if (!sameHolders(signIn.operation.heldBy, holders)) this.change(signIn, { heldBy: holders });
       this.schedule(signIn);
       return;
     }
     signIn.commit = this.commit(signIn, pair);
   }
 
+  /**
+   * The Claude Code processes that keep a login in the home `identity` from being imported, as the process table lists
+   * them: each whose home or credential store is the home, so it may still write the login there, and each whose home
+   * or store is unknown, unless it provably started before the home was made at `madeAtMs`. A process's settings are
+   * fixed when it starts, and the home's name was random until it was made, so an older process cannot name it.
+   */
+  private holders(identity: IClaudeContainerDirectoryIdentity, madeAtMs: number): IAuthSwitchClaudeSignInHolder[] {
+    const holders: IAuthSwitchClaudeSignInHolder[] = [];
+    for (const context of this.runningContexts()) {
+      const reason: IAuthSwitchClaudeSignInHolder['reason'] | null =
+        (context.nativeHomeIdentity !== null && sameContainerDirectory(context.nativeHomeIdentity, identity))
+          || (context.credentialStoreIdentity !== null && sameContainerDirectory(context.credentialStoreIdentity, identity))
+          ? 'on_home'
+          : (context.nativeHomeIdentity === null || context.credentialStoreIdentity === null)
+            && !startedBefore(context.startedAt, madeAtMs) ? 'uninspectable' : null;
+      if (reason !== null) holders.push({ pid: context.pid, startedAt: context.startedAt, reason });
+    }
+    return holders;
+  }
+
   private async commit(signIn: IClaudeSignIn, pair: IClaudeContainerPair): Promise<void> {
-    this.change(signIn, { state: 'committing', prompt: null });
+    this.change(signIn, { state: 'committing', prompt: null, heldBy: null });
     try {
       const result = await this.grants.importClaudeSignIn({ directory: signIn.directory,
         credentialRaw: pair.credentialRaw!, configRaw: pair.configRaw });
@@ -262,7 +308,8 @@ export class ClaudeSignInAuthority {
     signIn.timer = null;
     try { this.removeHome(signIn.parent, plugins.path.basename(signIn.directory)); }
     catch { /* The sign-in is over whatever the removal did; the next start removes a home that stayed. */ }
-    this.change(signIn, { state, prompt: null, error, result, finishedAt: new Date(this.now()).toISOString() });
+    this.change(signIn, { state, prompt: null, heldBy: null, error, result,
+      finishedAt: new Date(this.now()).toISOString() });
   }
 
   private change(signIn: IClaudeSignIn, patch: Partial<IAuthSwitchClaudeSignInOperation>): void {

package/ts_authswitch/classes.codexmanaged.ts

@@ -2,6 +2,7 @@ import * as plugins from './plugins.js';
 import { authSwitchRelease } from './packageidentity.js';
 import type { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
 import { requireVerifiedCodexServer, verifyManagedCodexContract, type IManagedCodexContract } from './codexcontract.js';
+import { psLstartInstant } from './classes.harnessprocesses.js';
 
 export interface IAuthSwitchManagedCodexOptions {
   /** Private runtime root; only the disposable control socket lives here. */
@@ -71,6 +72,21 @@ const claimsManagedCodexSocket = (argv: readonly Buffer[], socketPath: string):
   return false;
 };
 
+/**
+ * Rows of `ps -o pid=,lstart=` run with `TZ=UTC0`: the start is read by the shared `psLstartInstant`, null when it
+ * cannot be read (a claimant with a null start fails the inspection).
+ */
+export const managedCodexProcessRows = (output: string): Array<{ pid: number; startedAt: string | null }> => {
+  const rows: Array<{ pid: number; startedAt: string | null }> = [];
+  for (const line of output.split('\n')) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length !== 6) continue;
+    const pid = Number(parts[0]);
+    if (Number.isSafeInteger(pid) && pid > 0) rows.push({ pid, startedAt: psLstartInstant(parts.slice(1, 6)) });
+  }
+  return rows;
+};
+
 /** Same-user Linux process inspection for a bounded socket set, using exact /proc argv boundaries. */
 export const observeManagedCodexProcesses = async (
   socketPaths: readonly string[],
@@ -85,30 +101,28 @@ export const observeManagedCodexProcesses = async (
   }
   const uid = process.getuid?.();
   if (uid === undefined) throw new Error('Managed Codex process owner inspection is unavailable.');
+  // ps prints lstart in its TZ; under UTC0 the shared reader takes it as UTC (never Date.parse, which reads local time).
   const output = await new Promise<string>((resolve, reject) => {
     plugins.childProcess.execFile('ps', ['-ww', '-u', String(uid), '-o', 'pid=,lstart='],
-      { timeout: 5_000, maxBuffer: 8 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } },
+      { timeout: 5_000, maxBuffer: 8 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C', TZ: 'UTC0' } },
       (error, stdout) => error ? reject(new Error('Managed Codex process inspection failed.')) : resolve(stdout));
   });
-  const processes: Array<{ pid: number; startedAt: string; argv: Buffer[] }> = [];
-  for (const line of output.split('\n')) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length !== 6) continue;
-    const pid = Number(parts[0]);
-    const date = Date.parse(parts.slice(1, 6).join(' '));
-    if (Number.isSafeInteger(pid) && pid > 0 && Number.isFinite(date)) {
-      const argv = await linuxArgv(pid);
-      if (argv) processes.push({ pid, startedAt: new Date(date).toISOString(), argv });
-    }
+  const processes: Array<{ pid: number; startedAt: string | null; argv: Buffer[] }> = [];
+  for (const row of managedCodexProcessRows(output)) {
+    const argv = await linuxArgv(row.pid);
+    if (argv) processes.push({ ...row, argv });
   }
   const result = new Map<string, TManagedCodexProcessObservation>();
   for (const socketPath of unique) {
     const matches = processes.filter(process => claimsManagedCodexSocket(process.argv, socketPath));
-    result.set(socketPath, matches.length === 0
-      ? { state: 'absent' }
-      : matches.length === 1
-        ? { state: 'observed', pid: matches[0].pid, startedAt: matches[0].startedAt }
-        : { state: 'multiple_claimants' });
+    if (matches.length !== 1) {
+      result.set(socketPath, matches.length === 0 ? { state: 'absent' } : { state: 'multiple_claimants' });
+      continue;
+    }
+    const [claimant] = matches;
+    // A claimant whose start cannot be read has no identity to compare: the inspection fails, never reads as absent.
+    if (claimant.startedAt === null) throw new Error('Managed Codex process inspection failed.');
+    result.set(socketPath, { state: 'observed', pid: claimant.pid, startedAt: claimant.startedAt });
   }
   return result;
 };

package/ts_authswitch/classes.harnessprocesses.ts

@@ -41,12 +41,31 @@ const executablePatterns: Record<THarnessBinary, RegExp[]> = {
 const MAX_COMMAND_LINE = 200;
 const POSIX_FIELDS = 'pid=,ppid=,uid=,lstart=,comm=,args=';
 
-/** A bounded read of the current user's process table. Never a pattern-based kill list. */
-const enumeratePosix = (): IEnumeratedProcess[] => {
-  const uid = process.getuid!();
-  const output = plugins.childProcess.execFileSync('ps', ['-u', String(uid), '-o', POSIX_FIELDS], {
-    encoding: 'utf8', timeout: 5000, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' }, windowsHide: true,
-  });
+const LSTART_WEEKDAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const LSTART_MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/**
+ * The instant of `ps -o lstart` under `LC_ALL=C` and `TZ=UTC0`: the five tokens `weekday month day hh:mm:ss year`,
+ * read as UTC with `Date.UTC`. Never `Date.parse`, which reads them in local time: in the repeated hour of a DST
+ * fall-back that dates a process an hour early. Anything that is not exactly that shape, or names no real day, is null.
+ */
+export const psLstartInstant = (tokens: readonly string[]): string | null => {
+  if (tokens.length !== 5) return null;
+  const [weekdayToken, monthToken, dayToken, timeToken, yearToken] = tokens;
+  const weekday = LSTART_WEEKDAYS.indexOf(weekdayToken);
+  const month = LSTART_MONTHS.indexOf(monthToken);
+  const time = /^(\d{2}):(\d{2}):(\d{2})$/.exec(timeToken);
+  if (weekday < 0 || month < 0 || !time || !/^\d{1,2}$/.test(dayToken) || !/^\d{4}$/.test(yearToken)) return null;
+  const [day, year, hours, minutes, seconds] = [dayToken, yearToken, time[1], time[2], time[3]].map(Number);
+  if (hours > 23 || minutes > 59 || seconds > 59) return null;
+  const instant = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+  if (instant.getUTCFullYear() !== year || instant.getUTCMonth() !== month || instant.getUTCDate() !== day
+    || instant.getUTCDay() !== weekday) return null;
+  return instant.toISOString();
+};
+
+/** Rows of `ps -o pid=,ppid=,uid=,lstart=,comm=,args=` run with `TZ=UTC0`, for the process owner `uid` only. */
+export const parsePosixProcessTable = (output: string, uid: number): IEnumeratedProcess[] => {
   const processes: IEnumeratedProcess[] = [];
   for (const line of output.split('\n')) {
     // pid ppid uid, then the five fixed tokens of lstart, then comm and the full argument vector.
@@ -54,17 +73,29 @@ const enumeratePosix = (): IEnumeratedProcess[] => {
     if (parts.length < 9) continue;
     const [pid, parentPid, owner] = parts.slice(0, 3).map(Number);
     if (!Number.isInteger(pid) || pid <= 0 || owner !== uid) continue;
-    const started = Date.parse(parts.slice(3, 8).join(' '));
     const args = parts.slice(9);
     processes.push({
       pid, parentPid: Number.isInteger(parentPid) ? parentPid : null, command: parts[8],
       executable: args[0] ?? parts[8], commandLine: (args.length ? args.join(' ') : parts[8]).slice(0, MAX_COMMAND_LINE),
-      startedAt: Number.isFinite(started) ? new Date(started).toISOString() : null,
+      startedAt: psLstartInstant(parts.slice(3, 8)),
     });
   }
   return processes;
 };
 
+/**
+ * A bounded read of the current user's process table. Never a pattern-based kill list. `ps` prints lstart in its
+ * `TZ`, so it runs with `TZ=UTC0` and the start is read as UTC (`psLstartInstant`).
+ */
+const enumeratePosix = (): IEnumeratedProcess[] => {
+  const uid = process.getuid!();
+  const output = plugins.childProcess.execFileSync('ps', ['-u', String(uid), '-o', POSIX_FIELDS], {
+    encoding: 'utf8', timeout: 5000, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C', TZ: 'UTC0' },
+    windowsHide: true,
+  });
+  return parsePosixProcessTable(output, uid);
+};
+
 /** Windows reports an image name and a pid, with no owner, parent or start time in this view. */
 const enumerateWindows = (): IEnumeratedProcess[] => {
   const output = plugins.childProcess.execFileSync('tasklist', ['/FO', 'CSV', '/NH'], {

package/ts_authswitch/native-contracts.md

@@ -446,7 +446,7 @@ remote agent from `~/.claude/remote/ccd-cli/<version>` (since 2.1.295 a build na
 number as the command name while argv[0] carries the identity -- and a forked helper can
 carry the same `comm` while running something else entirely (`ugrep`). `HarnessProcesses`
 therefore matches argv[0] and those install paths (`ps -u <uid> -o pid=,ppid=,uid=,lstart=,comm=,args=`
-under `LC_ALL=C`, filtered on the uid column). It deliberately never matches the rest of the
+under `LC_ALL=C` and `TZ=UTC0`, filtered on the uid column; lstart is read as UTC with `Date.UTC`). It deliberately never matches the rest of the
 command line, which would count an unrelated process that merely mentions `claude`. The
 consequence is a known blind spot: an instance started through a wrapper that execs
 `node <path>/cli.js` has argv[0] `node`, so it is not listed. Listing signals nothing; the

package/ts_interfaces/interfaces.ts

@@ -5,7 +5,7 @@ import type {
   TControllerBrowserPaintAvailability,
   TControllerBrowserPaintTermination,
 } from './browserpaint.js';
-export const controllerProtocolVersion = 44 as const;
+export const controllerProtocolVersion = 45 as const;
 export const controllerUpgradeManagementVersion = 2 as const;
 export const controllerPackageName = 'agl' as const;
 /** The systemd user unit `agl service install` writes; a controller it runs reports it in its status. */

package/ts_interfaces/workercallers.ts

@@ -6,6 +6,8 @@ export const workerCallerLaunchGenerationEnvironmentVariable = 'AGL_MCP_LAUNCH_G
 export interface IFleetWorkerCallerLaunchBase {
   launchId: string;
   projectId: string;
+  /** The fleet worker the launch identifies, `${projectId}:${name}`: a worker holds one current launch. */
+  workerId: string;
 }
 
 /**
@@ -27,11 +29,15 @@ export interface IFleetClaudeProcess {
   startTicks: string;
 }
 
-export type TFleetWorkerCallerBinding = IFleetWorkerCallerLaunchBase & {
+export type TFleetWorkerCallerBinding = Omit<IFleetWorkerCallerLaunchBase, 'workerId'> & {
   nativeSessionId: string;
   expectedBindingRevision: number;
 } & (
-  | { harnessId: 'claude'; claudeProcess: IFleetClaudeProcess }
+  /**
+   * A Claude launch binds to its background job and to the job's current process; a job whose process already exited
+   * binds without one, and the next process of the same job proves itself when its bridge enrolls.
+   */
+  | { harnessId: 'claude'; claudeJobId: string; claudeProcess?: IFleetClaudeProcess }
   | { harnessId: 'codex' }
 );
 
@@ -53,12 +59,34 @@ export interface IFleetWorkerCallerHooks {
     ticketSessionId: string;
   }>;
   getWorkerCallerStatus(launchId: string): IWorkerCallerReadiness;
-  revokeWorkerCaller(request: {
-    launchId: string;
+  /**
+   * Revokes one launch, or the current launch of a worker, also one the controller kept from before a restart. Every
+   * reason but `generation_change` revokes it for good: its kept binding is deleted with it.
+   */
+  revokeWorkerCaller(request: ({ launchId: string } | { workerId: string }) & {
     reason: 'failure' | 'stop' | 'replacement' | 'generation_change' | 'cancelled';
   }): Promise<void>;
 }
 
+/** The background job a Claude worker's launch is bound to, as the controller asks the fleet about it. */
+export interface IWorkerClaudeJobRequest {
+  workerId: string;
+  projectId: string;
+  nativeSessionId: string;
+  jobId: string;
+}
+
+/**
+ * What a fresh Claude inventory shows of that job: `running` in one process, `settled` without a process, `ended` for
+ * this worker (the worker is gone or archived, continues in another session, or the session continues as another job),
+ * or `unproven` when the registry or the inventory could not be read or did not list the session once.
+ */
+export type TWorkerClaudeJobObservation =
+  | { state: 'running'; process: IFleetClaudeProcess }
+  | { state: 'settled' }
+  | { state: 'ended'; reason: string }
+  | { state: 'unproven'; reason: string };
+
 export interface IWorkerCallerSubject {
   kind: 'worker_launch';
   launchId: string;

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: 'agl',
-  version: '40.5.0',
+  version: '40.6.0',
   description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
 }

package/ts_web/accounts.plugins.ts

@@ -13,5 +13,9 @@ import * as authswitchUsageLimit from '../ts_authswitch/authority-usagelimit.js'
 import * as authswitchSubscription from '../ts_authswitch/authority-subscription.js';
 // An API key's month: the spend limit rule and dollar amounts, as the command line states them; it imports nothing.
 import * as authswitchSpend from '../ts_authswitch/authority-spend.js';
+// The service's contract, which the controller's interfaces load already: the processes holding a Claude sign-in, in
+// the words the command line uses.
+import * as authswitchAuthority from '../ts_authswitch/authority-contract.js';
 
-export { authswitchPreuseText, authswitchSpend, authswitchSubscription, authswitchUsageLimit, authswitchUsageWindows };
+export { authswitchAuthority, authswitchPreuseText, authswitchSpend, authswitchSubscription, authswitchUsageLimit,
+  authswitchUsageWindows };

package/ts_web/classes.accountsreadmodel.ts

@@ -1163,7 +1163,10 @@ const codexReleaseSlot = (
 const claudeSignInStatusText = (signInArg: interfaces.TControllerClaudeSignIn): string => (
   signInArg.state === 'committing'
     ? 'Adding the account…'
-    : 'Waiting for Claude Code to sign in. Run the command in a terminal and follow Claude Code there.'
+    : signInArg.heldBy
+      ? 'Claude Code signed in. The account is added once these Claude Code processes have ended: '
+        + `${plugins.authswitchAuthority.authSwitchClaudeSignInHoldersText(signInArg.heldBy)}.`
+      : 'Waiting for Claude Code to sign in. Run the command in a terminal and follow Claude Code there.'
 );
 
 /** One Claude sign-in in progress, with the command that completes it and a terminal to run it in. */