@bridge4dev/runner 0.65.0 → 0.66.0

package/dist/account-commands.d.ts

@@ -0,0 +1,44 @@
+import type { AccountLoginCodeResult, AccountLoginTarget, LoginStartResult } from './auth-relay.js';
+/**
+ * Several logins of one agent, on the wire (#422 S2, plan §8).
+ *
+ * Five commands, each a thin door over what `claude-homes.ts` already does on
+ * the machine. New NAMES rather than new arguments of `login_start`: an older
+ * runner silently ignores an argument it does not know and would sign in over
+ * the machine login while the API believed a saved account was being added; an
+ * unknown name it answers «Unknown command» at once.
+ *
+ * The API refuses to send any of these to a runner whose `capabilities.commands`
+ * does not name them, and `capabilities.accounts` says for which agents they
+ * work. Both lists come from here, so the announcement and the handler cannot
+ * disagree.
+ *
+ * The shapes are a hand-written copy of `@devbridge/shared` `agent-accounts.ts`
+ * (this package cannot import it); `account-commands.test.ts` parses real
+ * answers through the shared schemas.
+ */
+export declare const ACCOUNT_COMMANDS: readonly ["agent_accounts", "agent_account_login_start", "agent_account_login_code", "agent_account_activate", "agent_account_forget"];
+export type AccountCommand = (typeof ACCOUNT_COMMANDS)[number];
+/**
+ * The agents this runner keeps several logins for (`capabilities.accounts`,
+ * R11). Codex joins in S4; until then its account commands are refused with a
+ * sentence rather than half-served.
+ */
+export declare const ACCOUNT_AGENTS: readonly ["claude"];
+/** What `supervisor.ts` sends back as `command_result`, minus the envelope. */
+export type AccountCommandReply = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: string;
+    result?: unknown;
+};
+/** The two sign-in steps the commands drive – `AuthRelay`, or a test double. */
+export interface AccountSignIn {
+    startAccountLogin(target: AccountLoginTarget): Promise<LoginStartResult>;
+    submitAccountCode(code: string): Promise<AccountLoginCodeResult>;
+}
+export declare function isAccountCommand(name: string): name is AccountCommand;
+export declare function runAccountCommand(name: AccountCommand, args: Record<string, unknown>, signIn: AccountSignIn): Promise<AccountCommandReply>;
+//# sourceMappingURL=account-commands.d.ts.map

package/dist/account-commands.js

@@ -0,0 +1,99 @@
+import { AccountError, forgetAccount, isAccountId, listAccounts, setActiveAccount, } from './claude-homes.js';
+import { MACHINE_ACCOUNT_ID } from './login-marks.js';
+import { maskString } from './policy.js';
+/**
+ * Several logins of one agent, on the wire (#422 S2, plan §8).
+ *
+ * Five commands, each a thin door over what `claude-homes.ts` already does on
+ * the machine. New NAMES rather than new arguments of `login_start`: an older
+ * runner silently ignores an argument it does not know and would sign in over
+ * the machine login while the API believed a saved account was being added; an
+ * unknown name it answers «Unknown command» at once.
+ *
+ * The API refuses to send any of these to a runner whose `capabilities.commands`
+ * does not name them, and `capabilities.accounts` says for which agents they
+ * work. Both lists come from here, so the announcement and the handler cannot
+ * disagree.
+ *
+ * The shapes are a hand-written copy of `@devbridge/shared` `agent-accounts.ts`
+ * (this package cannot import it); `account-commands.test.ts` parses real
+ * answers through the shared schemas.
+ */
+export const ACCOUNT_COMMANDS = [
+    'agent_accounts',
+    'agent_account_login_start',
+    'agent_account_login_code',
+    'agent_account_activate',
+    'agent_account_forget',
+];
+/**
+ * The agents this runner keeps several logins for (`capabilities.accounts`,
+ * R11). Codex joins in S4; until then its account commands are refused with a
+ * sentence rather than half-served.
+ */
+export const ACCOUNT_AGENTS = ['claude'];
+export function isAccountCommand(name) {
+    return ACCOUNT_COMMANDS.includes(name);
+}
+function refusal(error) {
+    // `AccountError` is written for a person and carries no path (S1); anything
+    // else is masked like every other command error on this wire.
+    const message = error instanceof AccountError
+        ? error.message
+        : maskString(String(error instanceof Error ? error.message : error));
+    return { ok: false, error: message.slice(0, 500) };
+}
+function accountIdArg(value) {
+    return value === MACHINE_ACCOUNT_ID || isAccountId(value) ? value : null;
+}
+export async function runAccountCommand(name, args, signIn) {
+    const agent = args['agent'];
+    if (agent === 'codex') {
+        return { ok: false, error: 'several Codex logins are not supported by this runner yet' };
+    }
+    if (agent !== 'claude')
+        return { ok: false, error: 'agent must be claude or codex' };
+    try {
+        switch (name) {
+            case 'agent_accounts':
+                // The one place `claude auth status` runs on request (R14 a) – home by
+                // home, only where the known identity is stale.
+                return { ok: true, result: await listAccounts({ probeIdentity: true }) };
+            case 'agent_account_login_start': {
+                const target = args['target'];
+                if (target !== 'machine' && target !== 'saved') {
+                    return { ok: false, error: 'target must be machine or saved' };
+                }
+                return { ok: true, result: await signIn.startAccountLogin(target) };
+            }
+            case 'agent_account_login_code': {
+                const code = args['code'];
+                if (typeof code !== 'string' || !code.trim()) {
+                    return { ok: false, error: 'code is required' };
+                }
+                const result = await signIn.submitAccountCode(code);
+                return result.ok ? { ok: true, result } : { ok: false, error: result.detail, result };
+            }
+            case 'agent_account_activate': {
+                const id = accountIdArg(args['id']);
+                if (!id)
+                    return { ok: false, error: 'no such account on this server' };
+                // The usage cache is keyed by subscription, so a switch leaves it alone:
+                // the new row's figures are already its own (R16, §8).
+                return { ok: true, result: { active: setActiveAccount(id) } };
+            }
+            case 'agent_account_forget': {
+                const id = accountIdArg(args['id']);
+                if (!id)
+                    return { ok: false, error: 'no such account on this server' };
+                // Drops the forgotten row's usage slot itself (`forgetAccount`).
+                const { active } = forgetAccount(id);
+                return { ok: true, result: { ok: true, active } };
+            }
+        }
+    }
+    catch (error) {
+        return refusal(error);
+    }
+}
+//# sourceMappingURL=account-commands.js.map

package/dist/adapters/claude-usage.d.ts

@@ -59,7 +59,9 @@ export declare function applyUsagePercentages(windows: AgentRateLimitWindow[], r
 /**
  * How long the probe may run before it is written off (#390).
  *
- * Ninety seconds, and the number is measured rather than chosen. `/usage` was
+ * Ninety seconds, and the number is measured rather than chosen. (The docblock
+ * said ninety from #390 on while the constant still read 20 000, and about half
+ * the probes died at the ceiling – owner's decision D5 of #422 closes that.) `/usage` was
  * 3.7s when the old ceiling of 20s was set on 2026-08-15; it is not that
  * command any more. Since then the CLI prints «What's contributing to your
  * limits usage?», computed from the machine's OWN session history — 1.4 GB and
@@ -79,7 +81,7 @@ export declare function applyUsagePercentages(windows: AgentRateLimitWindow[], r
  * runs in the background, and since #390 there is at most ONE of it per
  * machine. The cost of NOT waiting was the panel losing two of its three rows.
  */
-export declare const USAGE_PROBE_TIMEOUT_MS = 20000;
+export declare const USAGE_PROBE_TIMEOUT_MS = 90000;
 /**
  * How long a successful reading is believed — the throttle for the whole box.
  *
@@ -100,7 +102,7 @@ export declare const USAGE_CACHE_MS: number;
  * the worst case is a single ~90s process a minute apart, not a pile.
  */
 export declare const USAGE_FAILURE_COOLDOWN_MS: number;
-export type UsageProbeRunner = (binary: string, cwd: string) => Promise<string | null>;
+export type UsageProbeRunner = (binary: string, cwd: string, env?: NodeJS.ProcessEnv) => Promise<string | null>;
 /**
  * Run `/usage` in a throwaway process and return what it printed.
  *
@@ -128,17 +130,66 @@ export type UsageProbeRunner = (binary: string, cwd: string) => Promise<string |
  * usage at all, because it reads neither OAuth nor the keychain — on the
  * subscription this whole file exists to report, it has nothing to say.
  */
-export declare function probeUsageText(binary: string, cwd: string, timeoutMs?: number): Promise<string | null>;
-/** A reading of the machine's plan, with the moment it was taken. */
+export declare function probeUsageText(binary: string, cwd: string, timeoutMs?: number, env?: NodeJS.ProcessEnv): Promise<string | null>;
+/**
+ * Whose numbers a reading is (#422 R16).
+ *
+ * The machine used to have one account, so «the machine's reading» was enough
+ * of a name. With several Claude homes it is not: a session measures under the
+ * home it STARTED with, and the cache is kept per subscription – `orgId` when
+ * the home's identity is known, the account id until then.
+ */
+export interface UsageAccount {
+    id: string;
+    /** `CLAUDE_CONFIG_DIR` of a saved account; null for the machine login. */
+    home: string | null;
+    orgId?: string;
+}
+/** The machine login, for callers that predate #422 and name no account. */
+export declare const MACHINE_USAGE_ACCOUNT: UsageAccount;
+/** The cache slot a reading of this account lives in. */
+export declare function usageCacheKey(account: {
+    id: string;
+    orgId?: string;
+}): string;
+/** Who a reading belongs to, read off the home right after it was measured. */
+export interface UsageSignature {
+    accountUuid?: string;
+    orgId?: string;
+}
+/** A reading of one account's plan, with the moment it was taken. */
 export interface UsageReading {
     rows: UsageRow[];
     measuredAtMs: number;
+    /** The account the CLI measured – from the home's own `.claude.json`. */
+    accountUuid?: string;
+    /** The subscription the numbers belong to. */
+    orgId?: string;
 }
 export declare function setUsageProbeRunner(run: UsageProbeRunner | null): void;
-/** Forget everything measured. For tests, and for a re-login that changes account. */
-export declare function invalidateUsageCache(): void;
 /**
- * What the machine last read, WITHOUT starting a measurement.
+ * Forget what was measured for one account (#422 R16).
+ *
+ * `forget` drops the forgotten row's slot, a replaced login drops the replaced
+ * row's, a new sign-in to the machine drops the machine's; `activate` drops
+ * nothing – the keys already keep accounts apart.
+ *
+ * Never cancels a probe that is running. Nulling «a probe is running» used to
+ * let the very next caller start a SECOND process beside the first, which then
+ * finished and wrote its figures under the account that had just been switched
+ * to. The running probe now finishes into the slot it was started for; a
+ * dropped slot is simply not where anybody reads any more, and the next probe
+ * waits in the queue behind it.
+ *
+ * Called with no account it forgets EVERYTHING, the queue included – a clean
+ * slate for a test. The product always names an account.
+ */
+export declare function invalidateUsageCache(account?: {
+    id: string;
+    orgId?: string;
+}): void;
+/**
+ * What the machine last read for this account, WITHOUT starting a measurement.
  *
  * The reason this exists is the defect #390 was actually about. A session's
  * window map starts empty, and its first `rate_limit_event` arrives 12-28
@@ -152,7 +203,10 @@ export declare function invalidateUsageCache(): void;
  * the machine already knows in its very first snapshot, and the probe that
  * follows only refreshes it.
  */
-export declare function lastUsageRows(): UsageReading | null;
+export declare function lastUsageRows(account?: {
+    id: string;
+    orgId?: string;
+}): UsageReading | null;
 export interface ReadUsageOptions {
     binary: string;
     /**
@@ -166,21 +220,31 @@ export interface ReadUsageOptions {
     cwd?: string;
     /** Fixed clock for tests; both the throttle and the stamp read it. */
     now?: number;
+    /** Whose plan to measure. Absent: the machine login, as before #422. */
+    account?: UsageAccount;
+    /** The probe's environment – the account's home, without the operator token. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Read who the home says it is, right after the probe. A reading whose
+     * subscription is not the account's own is thrown away rather than filed under
+     * the wrong name – the exact wrong statement #380 was about.
+     */
+    sign?: () => UsageSignature;
 }
 /**
- * The machine's plan percentages — measured at most once per {@link USAGE_CACHE_MS}.
+ * An account's plan percentages — measured at most once per {@link USAGE_CACHE_MS}.
  *
- * Two guards, and they answer different questions. The throttle stops us
- * measuring again too SOON; the in-flight join stops us measuring twice AT
- * ONCE. Only the second one fixes the pile-up this change is about: five
- * sessions reaching a turn end together used to start five copies of a
+ * Three guards, and they answer different questions. The throttle stops us
+ * measuring the same account again too SOON; the per-account join stops us
+ * measuring it twice AT ONCE; the queue stops two accounts measuring at once.
+ * Five sessions reaching a turn end together used to start five copies of a
  * 20-second CPU-bound process, each of which made the others slower — the same
  * self-sustaining shape `gitops.ts` writes about for `git_status`.
  *
  * Always resolves to the best reading we have, never to «nothing» just because
  * this attempt failed. A stale true number beats an empty panel — and the
  * reading carries the moment it was TAKEN, so the caller can tell a fresh
- * measurement from the one it already folded in (see {@link measuredAtMs}).
+ * measurement from the one it already folded in.
  */
 export declare function readUsageRows(options: ReadUsageOptions): Promise<UsageReading | null>;
 //# sourceMappingURL=claude-usage.d.ts.map

package/dist/adapters/claude-usage.js

@@ -232,7 +232,9 @@ export function applyUsagePercentages(windows, rows, options = {}) {
 /**
  * How long the probe may run before it is written off (#390).
  *
- * Ninety seconds, and the number is measured rather than chosen. `/usage` was
+ * Ninety seconds, and the number is measured rather than chosen. (The docblock
+ * said ninety from #390 on while the constant still read 20 000, and about half
+ * the probes died at the ceiling – owner's decision D5 of #422 closes that.) `/usage` was
  * 3.7s when the old ceiling of 20s was set on 2026-08-15; it is not that
  * command any more. Since then the CLI prints «What's contributing to your
  * limits usage?», computed from the machine's OWN session history — 1.4 GB and
@@ -252,7 +254,7 @@ export function applyUsagePercentages(windows, rows, options = {}) {
  * runs in the background, and since #390 there is at most ONE of it per
  * machine. The cost of NOT waiting was the panel losing two of its three rows.
  */
-export const USAGE_PROBE_TIMEOUT_MS = 20_000;
+export const USAGE_PROBE_TIMEOUT_MS = 90_000;
 /**
  * How long a successful reading is believed — the throttle for the whole box.
  *
@@ -333,7 +335,7 @@ function warnProbeFailure(error, timeoutMs, now) {
  * usage at all, because it reads neither OAuth nor the keychain — on the
  * subscription this whole file exists to report, it has nothing to say.
  */
-export function probeUsageText(binary, cwd, timeoutMs = USAGE_PROBE_TIMEOUT_MS) {
+export function probeUsageText(binary, cwd, timeoutMs = USAGE_PROBE_TIMEOUT_MS, env) {
     return new Promise((resolve) => {
         let settled = false;
         const finish = (text) => {
@@ -345,6 +347,12 @@ export function probeUsageText(binary, cwd, timeoutMs = USAGE_PROBE_TIMEOUT_MS)
         };
         const child = execFile(binary, ['--strict-mcp-config', '-p', '/usage', '--output-format', 'text'], {
             cwd,
+            // The account's home and nothing that outranks it (#422 S1 item 5): a
+            // probe run under the daemon's environment measures whichever login the
+            // DAEMON has, and with a saved account active that is somebody else's
+            // plan printed under this account's name. Absent only for a caller
+            // that measures the machine login exactly as before.
+            ...(env ? { env } : {}),
             timeout: timeoutMs,
             maxBuffer: 1024 * 1024,
             // SIGTERM can be trapped, SIGKILL cannot. A probe that ignored the
@@ -411,33 +419,41 @@ function probeDir() {
         return null;
     }
 }
+/** The machine login, for callers that predate #422 and name no account. */
+export const MACHINE_USAGE_ACCOUNT = { id: 'machine', home: null };
+/** The cache slot a reading of this account lives in. */
+export function usageCacheKey(account) {
+    return account.orgId ? `org:${account.orgId}` : `account:${account.id}`;
+}
+const slots = new Map();
 /**
- * The last reading that SUCCEEDED. A failed probe never clears it.
+ * The tail of the one-at-a-time queue: «a probe is running» is ONE per machine.
  *
- * This is the whole difference between «we could not measure just now» and «we
- * know nothing»: the first must keep showing the last true numbers, and only
- * the second is allowed to leave the panel empty.
- */
-let lastRows = null;
-/**
- * When {@link lastRows} was MEASURED — not when it was last handed out.
- *
- * Load-bearing rather than diagnostic (QA-390 MAJOR). A reading may be up to
- * {@link USAGE_CACHE_MS} old, and it is handed to a session at the end of every
- * turn. Meanwhile a `rate_limit_event` can have put a NEWER percentage into
- * that session's window, and `applyUsagePercentages` overwrites percentages
- * without asking how old they are — so an unqualified reading rolled 95% back
- * to the 60% the machine measured three minutes ago, on every turn. The stamp
- * is what lets the adapter tell «this is news» from «this is what you already
- * folded in».
+ * Not one per account. Two live sessions on two accounts would otherwise take
+ * turns throwing away each other's reading and starting their own — the pile-up
+ * of #390, rebuilt out of accounts instead of sessions (R16). A second account
+ * waits for the first probe to finish and then measures; nobody measures twice
+ * at once.
  */
-let measuredAtMs = 0;
-/** When the last attempt FINISHED, successful or not — the throttle's clock. */
-let attemptedAtMs = 0;
-/** Did that attempt produce rows? Decides which of the two intervals applies. */
-let lastAttemptOk = false;
-/** The probe currently running, so overlapping callers share it. */
-let inFlight = null;
+let probeQueue = Promise.resolve();
+function slotFor(key) {
+    let slot = slots.get(key);
+    if (!slot) {
+        slot = { rows: null, measuredAtMs: 0, attemptedAtMs: 0, lastAttemptOk: false, pending: null };
+        slots.set(key, slot);
+    }
+    return slot;
+}
+function readingOf(slot) {
+    if (!slot?.rows)
+        return null;
+    return {
+        rows: slot.rows,
+        measuredAtMs: slot.measuredAtMs,
+        ...(slot.accountUuid ? { accountUuid: slot.accountUuid } : {}),
+        ...(slot.orgId ? { orgId: slot.orgId } : {}),
+    };
+}
 /**
  * The probe the cache runs. Replaced only by tests.
  *
@@ -450,21 +466,41 @@ let inFlight = null;
  * `cwd` did not exist, and this change stopped the probe using the session's
  * `cwd` at all.
  */
-let probeRunner = (binary, cwd) => probeUsageText(binary, cwd);
+const defaultProbeRunner = (binary, cwd, env) => probeUsageText(binary, cwd, USAGE_PROBE_TIMEOUT_MS, env);
+let probeRunner = defaultProbeRunner;
 export function setUsageProbeRunner(run) {
-    probeRunner = run ?? ((binary, cwd) => probeUsageText(binary, cwd));
+    probeRunner = run ?? defaultProbeRunner;
 }
-/** Forget everything measured. For tests, and for a re-login that changes account. */
-export function invalidateUsageCache() {
-    lastRows = null;
-    measuredAtMs = 0;
-    attemptedAtMs = 0;
-    lastAttemptOk = false;
-    inFlight = null;
-    warnedAtMs.clear();
+/**
+ * Forget what was measured for one account (#422 R16).
+ *
+ * `forget` drops the forgotten row's slot, a replaced login drops the replaced
+ * row's, a new sign-in to the machine drops the machine's; `activate` drops
+ * nothing – the keys already keep accounts apart.
+ *
+ * Never cancels a probe that is running. Nulling «a probe is running» used to
+ * let the very next caller start a SECOND process beside the first, which then
+ * finished and wrote its figures under the account that had just been switched
+ * to. The running probe now finishes into the slot it was started for; a
+ * dropped slot is simply not where anybody reads any more, and the next probe
+ * waits in the queue behind it.
+ *
+ * Called with no account it forgets EVERYTHING, the queue included – a clean
+ * slate for a test. The product always names an account.
+ */
+export function invalidateUsageCache(account) {
+    if (account === undefined) {
+        slots.clear();
+        warnedAtMs.clear();
+        // A probe a previous test left hanging must not hold every later one.
+        // Production probes settle on their own (the watchdog in `probeUsageText`).
+        probeQueue = Promise.resolve();
+        return;
+    }
+    slots.delete(usageCacheKey(account));
 }
 /**
- * What the machine last read, WITHOUT starting a measurement.
+ * What the machine last read for this account, WITHOUT starting a measurement.
  *
  * The reason this exists is the defect #390 was actually about. A session's
  * window map starts empty, and its first `rate_limit_event` arrives 12-28
@@ -478,61 +514,101 @@ export function invalidateUsageCache() {
  * the machine already knows in its very first snapshot, and the probe that
  * follows only refreshes it.
  */
-export function lastUsageRows() {
-    return lastRows ? { rows: lastRows, measuredAtMs } : null;
+export function lastUsageRows(account = MACHINE_USAGE_ACCOUNT) {
+    return readingOf(slots.get(usageCacheKey(account)));
 }
 /**
- * The machine's plan percentages — measured at most once per {@link USAGE_CACHE_MS}.
+ * An account's plan percentages — measured at most once per {@link USAGE_CACHE_MS}.
  *
- * Two guards, and they answer different questions. The throttle stops us
- * measuring again too SOON; the in-flight join stops us measuring twice AT
- * ONCE. Only the second one fixes the pile-up this change is about: five
- * sessions reaching a turn end together used to start five copies of a
+ * Three guards, and they answer different questions. The throttle stops us
+ * measuring the same account again too SOON; the per-account join stops us
+ * measuring it twice AT ONCE; the queue stops two accounts measuring at once.
+ * Five sessions reaching a turn end together used to start five copies of a
  * 20-second CPU-bound process, each of which made the others slower — the same
  * self-sustaining shape `gitops.ts` writes about for `git_status`.
  *
  * Always resolves to the best reading we have, never to «nothing» just because
  * this attempt failed. A stale true number beats an empty panel — and the
  * reading carries the moment it was TAKEN, so the caller can tell a fresh
- * measurement from the one it already folded in (see {@link measuredAtMs}).
+ * measurement from the one it already folded in.
  */
 export function readUsageRows(options) {
+    const account = options.account ?? MACHINE_USAGE_ACCOUNT;
+    const key = usageCacheKey(account);
+    const slot = slotFor(key);
     const now = options.now ?? Date.now();
-    const interval = lastAttemptOk ? USAGE_CACHE_MS : USAGE_FAILURE_COOLDOWN_MS;
-    if (attemptedAtMs !== 0 && now - attemptedAtMs < interval) {
-        return Promise.resolve(lastUsageRows());
+    const interval = slot.lastAttemptOk ? USAGE_CACHE_MS : USAGE_FAILURE_COOLDOWN_MS;
+    if (slot.attemptedAtMs !== 0 && now - slot.attemptedAtMs < interval) {
+        return Promise.resolve(readingOf(slot));
     }
-    if (inFlight)
-        return inFlight;
+    if (slot.pending)
+        return slot.pending;
     const cwd = options.cwd ?? probeDir();
     if (cwd === null)
-        return Promise.resolve(lastUsageRows());
-    const pending = probeRunner(options.binary, cwd)
+        return Promise.resolve(readingOf(slot));
+    // After the slot was dropped (a forgotten or replaced account) the reading
+    // lands in the orphan and nobody sees it; whoever asks gets the slot that is
+    // current now.
+    const answer = () => slots.get(key) === slot ? readingOf(slot) : lastUsageRows(account);
+    const pending = probeQueue
+        .then(() => 
+    // Waited in the queue behind somebody else's probe: the account may have
+    // been forgotten or replaced meanwhile. A probe of a slot nobody reads, or
+    // under a home that is gone, would only let the CLI recreate that home.
+    slots.get(key) !== slot || (account.home !== null && !fs.existsSync(account.home))
+        ? null
+        : probeRunner(options.binary, cwd, options.env))
         .then((text) => {
         const rows = text ? parseUsageText(text) : [];
-        attemptedAtMs = options.now ?? Date.now();
-        lastAttemptOk = rows.length > 0;
-        // Zero rows is not an answer worth keeping: it means the wording moved or
-        // the CLI said nothing, and the previous true reading is still the best
-        // thing we have to show.
-        if (rows.length > 0) {
-            lastRows = rows;
-            measuredAtMs = attemptedAtMs;
+        const signature = rows.length > 0 ? signReading(options.sign) : {};
+        // The home answered for a different subscription than the account we
+        // measured for – a re-login under our feet. Not this account's numbers.
+        const foreign = account.orgId !== undefined &&
+            signature.orgId !== undefined &&
+            signature.orgId !== account.orgId;
+        slot.attemptedAtMs = options.now ?? Date.now();
+        slot.lastAttemptOk = rows.length > 0 && !foreign;
+        if (foreign) {
+            log.warn('claude: /usage measured a different subscription than the account — dropped', {
+                account: account.id,
+            });
+        }
+        else if (rows.length > 0) {
+            // Zero rows is not an answer worth keeping: it means the wording moved
+            // or the CLI said nothing, and the previous true reading is still the
+            // best thing we have to show.
+            slot.rows = rows;
+            slot.measuredAtMs = slot.attemptedAtMs;
+            slot.accountUuid = signature.accountUuid;
+            slot.orgId = account.orgId ?? signature.orgId;
         }
-        return lastUsageRows();
+        return answer();
     })
         .catch((error) => {
         // `probeUsageText` resolves rather than rejects, so this is a seat that
         // threw or a parser that did — either way the reading is unchanged.
         log.debug('claude: /usage probe threw', { error: String(error) });
-        attemptedAtMs = options.now ?? Date.now();
-        lastAttemptOk = false;
-        return lastUsageRows();
+        slot.attemptedAtMs = options.now ?? Date.now();
+        slot.lastAttemptOk = false;
+        return answer();
     })
         .finally(() => {
-        inFlight = null;
+        slot.pending = null;
     });
-    inFlight = pending;
+    slot.pending = pending;
+    probeQueue = pending.catch(() => undefined);
     return pending;
 }
+function signReading(sign) {
+    if (!sign)
+        return {};
+    try {
+        return sign();
+    }
+    catch {
+        // A home we could not read signs nothing; the reading still belongs to the
+        // account it was measured for.
+        return {};
+    }
+}
 //# sourceMappingURL=claude-usage.js.map

package/dist/adapters/claude.d.ts

@@ -1,8 +1,37 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { type AgentAdapter, type AgentQuestion, type AgentSession, type SessionSpec } from './types.js';
+import { type AgentAdapter, type AgentMode, type AgentQuestion, type AgentSession, type SessionSpec } from './types.js';
+import { type SessionAccount } from '../claude-homes.js';
 export declare function truncate(text: string, limit?: number): string;
 /** Exported for the one-shot commit-message run (session 14), same rules. */
 export declare function scrubbedEnv(): Record<string, string>;
+/**
+ * The one env var the allowlist above refuses, added back for exactly one mode
+ * (ticket #156).
+ *
+ * The CLI's own guard, read out of the binary verbatim:
+ *
+ * ```js
+ * if (t === "bypassPermissions" || r) {
+ *   if (typeof process.getuid === "function" && process.getuid() === 0
+ *       && process.env.IS_SANDBOX !== "1" && !Z.CLAUDE_CODE_BUBBLEWRAP)
+ *     console.error("--dangerously-skip-permissions cannot be used with root/sudo privileges …"),
+ *     process.exit(1)
+ * }
+ * ```
+ *
+ * The runner's default install is root (`install.sh`), so on an ordinary
+ * machine «Unrestricted» did not degrade — it killed the session at launch with
+ * exit code 1. On the machine this was found on it happened to start, because
+ * `~/.claude/settings.json` carries `env: { IS_SANDBOX: "1" }` and this adapter
+ * loads user settings; that is a hole in the scrub covering a bug, not a fix.
+ *
+ * The condition here is the CLI's own, no wider: `full` AND uid 0. It is safe
+ * precisely where it is applied — `bypassPermissions` is the mode in which the
+ * SDK never calls `canUseTool` (it says so itself), so layer 1 is already inert
+ * and there is nothing left for `IS_SANDBOX` to weaken. In every other mode the
+ * scrub stands, which is what the comment on `ENV_ALLOWLIST` has always meant.
+ */
+export declare function agentEnv(mode: AgentMode, sessionId: string, account?: Pick<SessionAccount, 'kind' | 'home'>): Record<string, string>;
 /**
  * The whole `AskUserQuestion` payload, not just its first line.
  *