@bridge4dev/runner 0.22.1 → 0.27.0

package/dist/auth-relay.js

@@ -5,6 +5,8 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { log } from './log.js';
 import { maskString } from './policy.js';
+import { runnerIdentity, whichExecutable } from './environment.js';
+import { applyStoredClaudeToken, clearStoredClaudeToken, extractOauthToken, storeClaudeToken, storedClaudeToken, } from './agent-auth.js';
 import { adoptLoginResult, discardStagingHome, prepareStagingHome, repairCodexAuth, stagingCodexHomePath, } from './adapters/codex-home.js';
 const execFileAsync = promisify(execFile);
 /* eslint-disable no-control-regex -- this module parses raw pty output, so
@@ -18,6 +20,18 @@ const URL_PATTERNS = {
     claude: /https:\/\/(?:claude\.com|claude\.ai)\/[^\s\x07\x1b"']+/,
     codex: /https:\/\/[^\s\x07\x1b"']+/,
 };
+/**
+ * Rejoin a secret the pty split across lines, so the masker can see it.
+ *
+ * `maskString` matches `sk-ant-[A-Za-z0-9_-]{8,}`, which a line break inside
+ * the token defeats — and the pty wraps at its width, so a ~100-character
+ * token arrives in pieces as a matter of course. Measured: the head gets
+ * masked and the tail is printed verbatim into an error detail that travels to
+ * the dashboard. Rejoining first costs nothing and closes it.
+ */
+export function rejoinWrappedSecrets(text) {
+    return text.replace(/sk-ant-[A-Za-z0-9_-]*(?:\n[A-Za-z0-9_-]+)+/g, (match) => match.replace(/\n/g, ''));
+}
 /** Strip ANSI/OSC control sequences so text matching sees plain output. */
 export function stripControl(raw) {
     return raw
@@ -38,18 +52,132 @@ export function extractDeviceCode(raw) {
     // Device-auth user codes look like XXXX-XXXX (letters/digits).
     return stripControl(raw).match(/\b[A-Z0-9]{4,8}-[A-Z0-9]{4,8}\b/)?.[0] ?? null;
 }
+/**
+ * Did the CLI reject the subcommand itself, rather than fail the login?
+ *
+ * Commander prints «unknown command» / «error: unknown option» and exits
+ * before any network call. Anything else — a refused grant, no subscription, a
+ * DNS failure — is a real answer and must NOT be retried on the legacy command,
+ * or we would quietly downgrade a healthy machine to an inference-only token.
+ */
+function looksLikeUnsupportedSubcommand(output) {
+    // Anchored to Commander's own usage-error wording. The loose version matched
+    // anywhere in the relayed CLI output, so a genuine login failure that merely
+    // mentioned an unknown option would silently downgrade a healthy machine to
+    // an inference-only token — the very thing this release stops doing.
+    return /error:\s*unknown (?:command|option)\b|unrecognized subcommand/i.test(output);
+}
+/**
+ * What «sign in» actually is, per agent.
+ *
+ * `claude auth login` and NOT `claude setup-token`, and the difference is the
+ * whole of ticket «Sign in does nothing». Measured against the 2.1.220 binary
+ * and stated outright in Anthropic's docs: `setup-token` mints a long-lived
+ * INFERENCE-ONLY token, prints it to the terminal, and «does not save the token
+ * anywhere». It never touches `~/.claude/.credentials.json` — the file
+ * `claudeAuthStatus()` below reads to decide whether this machine is signed in.
+ * So the relay completed a real OAuth flow, the CLI exited 0, we reported
+ * success, and the panel's immediate re-probe answered «No Claude login on this
+ * server». Nobody was wrong; the two halves were simply about different things.
+ *
+ * `claude auth login --claudeai` is the same OAuth flow through the same pty
+ * harness — verified live: it prints the authorize URL and then waits on stdin
+ * with «Paste code here if prompted >» — except it persists the credential and
+ * asks for the full subscription scope rather than inference alone.
+ *
+ * `--claudeai` is explicit so the CLI never stops to ask «subscription or
+ * Console?»: a menu waiting for an arrow key is indistinguishable, from here,
+ * from a login that hung.
+ */
 const LOGIN_COMMANDS = {
-    claude: 'claude setup-token',
+    claude: 'claude auth login --claudeai',
     codex: 'codex login --device-auth',
 };
+/**
+ * The pre-0.27.0 command, kept for one job only: a `claude` old enough to have
+ * no `auth login` subcommand. There the CLI exits immediately with a usage
+ * error, and leaving that machine with no way to sign in at all would be a
+ * worse regression than the bug this replaced. On that path we capture the
+ * printed token ourselves (see `agent-auth.ts`) so the outcome is still a
+ * login the panel can see.
+ */
+const CLAUDE_LEGACY_LOGIN = 'claude setup-token';
+/**
+ * A pty on a headless server must not try to launch a browser.
+ *
+ * `claude auth login` prints «Opening browser to sign in…» and calls the
+ * platform opener first. On a server that is merely noise, but on a machine
+ * with a desktop session it pops a window in front of whoever is sitting there
+ * — for a sign-in they did not start, on a host they may not own. The URL is
+ * printed regardless, which is the only part this flow uses.
+ */
+function relayEnv(extra = {}) {
+    const env = { ...process.env, ...extra };
+    env['BROWSER'] = 'true';
+    delete env['DISPLAY'];
+    delete env['WAYLAND_DISPLAY'];
+    return env;
+}
+/**
+ * Is the command this relay is about to run actually present?
+ *
+ * Split out because the answer differs by shape: a bare name is looked up on
+ * PATH, while an absolute path (what the tests inject, and what a hand-written
+ * config could hold) is checked where it points. Without this the missing-CLI
+ * case surfaced as «login exited before printing a sign-in URL: script:
+ * command not found» — an error about the pty helper, on a machine whose real
+ * problem was that nobody had installed the agent for that user. That was
+ * axon-prod-01 exactly: a dedicated user, an empty home, no `claude` anywhere.
+ */
+function commandExists(command) {
+    const binary = command.trim().split(/\s+/)[0] ?? '';
+    if (!binary)
+        return false;
+    if (binary.includes(path.sep)) {
+        try {
+            fs.accessSync(binary, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return whichExecutable(binary) !== null;
+}
 export class AuthRelay {
     commands;
+    deps;
     active = null;
-    constructor(commands = LOGIN_COMMANDS) {
+    constructor(commands = LOGIN_COMMANDS, deps = {}) {
         this.commands = commands;
+        this.deps = deps;
     }
     /** Start (or restart) a login flow and wait until the sign-in URL appears. */
     async start(agent) {
+        this.cancel();
+        const command = this.commands[agent] ?? '';
+        if (!commandExists(command)) {
+            const binary = command.trim().split(/\s+/)[0] ?? agent;
+            throw new Error(`\`${binary}\` is not installed for ${runnerIdentity().user} on this server — ` +
+                'install the agent CLI for that user (or use the installer’s --user mode, which does it) and try again');
+        }
+        if (!whichExecutable('script')) {
+            // util-linux, and the only reason a pty exists here at all.
+            throw new Error('the `script` command (util-linux) is missing on this server — the sign-in needs it to run the agent CLI on a terminal');
+        }
+        try {
+            return await this.startWith(agent, this.commands[agent] ?? '', false);
+        }
+        catch (error) {
+            // Only the one recoverable shape: a `claude` too old to have `auth
+            // login`. Everything else is the answer, not a reason to try again.
+            if (agent !== 'claude' || !looksLikeUnsupportedSubcommand(String(error)))
+                throw error;
+            log.warn('auth-relay: this claude has no `auth login` — falling back to setup-token');
+            return this.startWith(agent, CLAUDE_LEGACY_LOGIN, true);
+        }
+    }
+    async startWith(agent, command, captureToken) {
         this.cancel();
         // Codex logs into a THROWAWAY home and is promoted only on success. The
         // old flow deleted the shared credential link up front, so abandoning the
@@ -57,10 +185,10 @@ export class AuthRelay {
         // with no way back except restarting the daemon — and writing through the
         // link would have overwritten the host user's own account (QA-100 MINOR-5).
         const stagingHome = agent === 'codex' ? prepareStagingHome() : null;
-        const proc = spawn('script', ['-qec', this.commands[agent], '/dev/null'], {
+        const proc = spawn('script', ['-qec', command, '/dev/null'], {
             stdio: ['pipe', 'pipe', 'pipe'],
             // Codex must log in to a home WE control, never the host user's ~/.codex.
-            ...(stagingHome ? { env: { ...process.env, CODEX_HOME: stagingHome } } : {}),
+            env: relayEnv(stagingHome ? { CODEX_HOME: stagingHome } : {}),
         });
         const relay = {
             agent,
@@ -68,6 +196,8 @@ export class AuthRelay {
             buffer: '',
             exited: false,
             exitCode: null,
+            command,
+            captureToken,
             killTimer: setTimeout(() => this.cancel(), RELAY_MAX_LIFETIME_MS),
         };
         relay.killTimer.unref();
@@ -92,6 +222,12 @@ export class AuthRelay {
             try {
                 if (code === 0 && adoptLoginResult(stagingCodexHomePath())) {
                     log.info('codex: device login completed — credential adopted');
+                    // The ONLY place a Codex sign-in can be reported as finished. Its
+                    // flow never sends `login_code` (device auth needs no paste-back),
+                    // so without this line a refusal we recorded earlier would keep the
+                    // panel demanding a re-login the user has just done — #121's own
+                    // complaint, reproduced on the other half of the panel (QA-117 H1).
+                    clearAgentAuthFailure('codex');
                 }
                 else {
                     discardStagingHome();
@@ -115,7 +251,7 @@ export class AuthRelay {
                 return { url, ...(code ? { code } : {}), expectsCode: agent === 'claude' };
             }
             if (relay.exited) {
-                const tail = maskString(stripControl(relay.buffer)).slice(-400);
+                const tail = maskString(rejoinWrappedSecrets(stripControl(relay.buffer))).slice(-400);
                 this.cancel();
                 throw new Error(`${agent} login exited before printing a sign-in URL: ${tail}`);
             }
@@ -142,21 +278,79 @@ export class AuthRelay {
         while (Date.now() < deadline) {
             const fresh = stripControl(relay.buffer.slice(bufferMark));
             if (relay.exited) {
+                const raw = relay.buffer;
                 this.cancel();
-                if (relay.exitCode === 0)
-                    return { ok: true };
-                return { ok: false, detail: maskString(fresh).slice(-400) || 'Login failed' };
+                if (relay.exitCode !== 0) {
+                    return {
+                        ok: false,
+                        detail: maskString(rejoinWrappedSecrets(fresh)).slice(-400) || 'Login failed',
+                    };
+                }
+                // Exit 0 is the CLI's opinion. Ours has to be «is this machine signed
+                // in now», because those two came apart before and nobody noticed for
+                // weeks: `setup-token` exits 0 over a credential it never stored.
+                return this.confirmSignedIn(relay, raw);
             }
             if (/invalid|error|failed|expired/i.test(fresh)) {
                 // The CLI usually re-prompts after a bad code; surface it and keep
                 // the relay alive so the user can retry with a corrected code.
-                return { ok: false, detail: maskString(fresh).trim().slice(-400) };
+                return { ok: false, detail: maskString(rejoinWrappedSecrets(fresh)).trim().slice(-400) };
             }
             await sleep(300);
         }
         this.cancel();
         return { ok: false, detail: 'Timed out waiting for the login to complete' };
     }
+    /**
+     * The CLI exited 0 — but is the machine actually signed in?
+     *
+     * Asked rather than assumed. Reporting a success the panel then contradicts
+     * one second later is worse than reporting a failure: it sends the person
+     * looking for a permissions problem that does not exist, which is exactly
+     * what happened on axon-prod-01.
+     */
+    async confirmSignedIn(relay, raw) {
+        if (relay.agent !== 'claude')
+            return { ok: true };
+        // Legacy `setup-token`: the token exists only in the output. Keep it, or
+        // the whole flow was for nothing.
+        if (relay.captureToken) {
+            const token = extractOauthToken(stripControl(raw));
+            if (!token) {
+                return {
+                    ok: false,
+                    detail: 'the sign-in finished but this older Claude CLI printed no usable token — ' +
+                        'update the Claude CLI on the server and try again',
+                };
+            }
+            try {
+                storeClaudeToken(token);
+                applyStoredClaudeToken();
+            }
+            catch (error) {
+                return { ok: false, detail: `could not store the token on this server: ${String(error)}` };
+            }
+            log.info('auth-relay: stored a long-lived Claude token for this runner');
+            clearAgentAuthFailure('claude');
+            return { ok: true, detail: 'signed in with a long-lived token stored on this server' };
+        }
+        // `claude auth login` writes the credential just before it exits; give the
+        // filesystem a couple of beats rather than racing it.
+        const probe = this.deps.claudeStatus ?? claudeAuthStatus;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            const status = await probe();
+            if (status.status === 'ok') {
+                clearAgentAuthFailure('claude');
+                return { ok: true };
+            }
+            await sleep(300);
+        }
+        return {
+            ok: false,
+            detail: 'the sign-in completed but no login was stored on this server — ' +
+                'check that the user the runner runs as can write its own ~/.claude directory',
+        };
+    }
     cancel() {
         const relay = this.active;
         if (!relay)
@@ -174,36 +368,220 @@ export class AuthRelay {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-// ─── Auth health probe ───────────────────────────────────────────────
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+/**
+ * A millisecond timestamp we are willing to hand to `new Date(...)`.
+ *
+ * The bound is not decoration: `new Date(1e21).toISOString()` throws
+ * `RangeError`, and thrown out of here it takes BOTH agents' verdicts down
+ * with it (they share one `Promise.all`) on every poll, forever, because only
+ * successes are cached (QA-117 M1).
+ */
+const MAX_TIMESTAMP_MS = 8.64e15;
+function asTimestamp(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    return Math.abs(value) <= MAX_TIMESTAMP_MS ? value : undefined;
+}
 /**
- * Claude: the subscription token's expiry is recorded in the CLI's own
- * credentials file. The RUNNER reads it (its own host user's file) — the
- * agent itself is still denied this path by layer-1 policy.
+ * Claude: the subscription login is recorded in the CLI's own credentials file.
+ * The RUNNER reads it (its own host user's file) — the agent itself is still
+ * denied this path by layer-1 policy.
+ *
+ * `expiresAt` is NOT the login. It is the expiry of a short-lived access token
+ * (~8 hours on a live file), and next to it sits `refreshToken` with
+ * `refreshTokenExpiresAt` ~26 days out, which the CLI spends silently on its
+ * next run. Judging the login by `expiresAt` alone is why every server nobody
+ * had touched since the morning reported "login expired — re-login needed"
+ * over a login that was good for another three weeks (#121). Codex has carried
+ * exactly this guard since day one (`readCodexCredential`); Claude did not.
+ *
+ * Deliberately NOT asking the CLI. `claude auth status --json` looks like an
+ * arbiter and is not one: measured live (SDK binary 2.1.218), it answers
+ * `loggedIn: true` for a credential whose access token has expired AND which
+ * carries no refresh token at all — i.e. for a genuinely dead login. It never
+ * leaves the machine, so it cannot see a server-side revocation either. It
+ * would have cost a ~800 ms / ~300 MB subprocess per poll under `MemoryMax=2G`
+ * (gotcha #100) and echoed the account's e-mail and org name to every member of
+ * the organization, in exchange for no truth at all. A revoked login is caught
+ * instead by `noteAgentAuthFailure` below — from a real refusal, not a guess.
  */
 export async function claudeAuthStatus(homedir = os.homedir()) {
     if (process.env['CLAUDE_CODE_OAUTH_TOKEN']) {
         return { status: 'ok', detail: 'CLAUDE_CODE_OAUTH_TOKEN is configured' };
     }
+    /**
+     * A token this runner captured itself (the `setup-token` fallback) is the
+     * LAST word, never the first.
+     *
+     * It used to short-circuit ahead of the credentials file, and that was three
+     * bugs in one line: a real `/login` afterwards could never show through, the
+     * post-exchange re-probe could not fail (so `confirmSignedIn` always agreed
+     * with itself), and there was no way to get back to «signed out» short of
+     * deleting a file nobody documents. Read below, after the file has had its
+     * say — and read from disk rather than from the environment, so `doctor` (a
+     * different process, which never applied it) gives the same verdict as the
+     * daemon.
+     */
+    const fallbackToken = () => storedClaudeToken()
+        ? {
+            status: 'ok',
+            detail: 'signed in with a long-lived token stored on this server',
+        }
+        : null;
     const file = path.join(homedir, '.claude', '.credentials.json');
+    let raw;
     try {
-        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-        const oauth = parsed.claudeAiOauth;
-        if (!oauth)
-            return { status: 'missing', detail: 'No subscription login found' };
-        const expiresAt = oauth.expiresAt ? new Date(oauth.expiresAt).toISOString() : undefined;
-        if (oauth.expiresAt && oauth.expiresAt < Date.now()) {
-            return { status: 'expired', ...(expiresAt ? { expiresAt } : {}) };
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        // Never signed in here is a different answer from "we could not look".
+        // EACCES on somebody else's HOME used to read as "not signed in", which
+        // sends the user re-authenticating a credential that is sitting right
+        // there (the same mistake #121 is about, one layer down).
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            return fallbackToken() ?? { status: 'missing', detail: 'No Claude login on this server' };
         }
+        // No `log.warn` here: this probe is on a 60-second timer since #121, and a
+        // machine with EACCES on that file would write the same line forever.
+        // `logVerdictChange` already reports the `unknown`, once, when it starts
+        // (QA-117 L5).
         return {
-            status: 'ok',
-            ...(expiresAt ? { expiresAt } : {}),
-            ...(oauth.subscriptionType ? { detail: `subscription ${oauth.subscriptionType}` } : {}),
+            status: 'unknown',
+            detail: `could not read the login on this server (${code ?? 'unknown error'})`,
         };
     }
+    let oauth;
+    try {
+        oauth = JSON.parse(raw).claudeAiOauth;
+    }
     catch {
-        return { status: 'missing', detail: 'No Claude login on this server' };
+        // Truncated or hand-edited file: the CLI cannot use it either, and signing
+        // in again is the fix — so say `missing` (which offers that button) rather
+        // than `unknown` (which offers nothing).
+        return { status: 'missing', detail: 'the stored login could not be read — sign in again' };
+    }
+    // A parseable file is not a credential. `{"claudeAiOauth":{}}` is what a
+    // partial write and a hand-edit both leave behind, and reading it as a
+    // healthy login puts a green dot and NO way out on the panel — «I cannot
+    // tell» turned into «all good», which is the rule this ticket exists to
+    // uphold, upside down (QA-117 M2).
+    if (!oauth || typeof oauth !== 'object' || Array.isArray(oauth)) {
+        return { status: 'missing', detail: 'the stored login could not be read — sign in again' };
+    }
+    const hasAccess = isNonEmptyString(oauth.accessToken);
+    const hasRefresh = isNonEmptyString(oauth.refreshToken);
+    const now = Date.now();
+    const accessExpiry = asTimestamp(oauth.expiresAt);
+    const refreshExpiry = asTimestamp(oauth.refreshTokenExpiresAt);
+    // Nothing recognisable in the blob at all — no token, not even a date. That
+    // is «never signed in here», and it must offer the button that fixes it.
+    if (!hasAccess && !hasRefresh && accessExpiry === undefined) {
+        return fallbackToken() ?? { status: 'missing', detail: 'No subscription login found' };
+    }
+    // A date we can read outranks the token beside it (the pre-#121 contract, and
+    // the reason a dated-but-token-less fixture still reads as expired); with no
+    // readable date, the presence of the token is all we have.
+    const accessLive = accessExpiry === undefined ? hasAccess : accessExpiry > now;
+    // No `refreshTokenExpiresAt` next to a refresh token means the CLI did not
+    // record one — that is not evidence of death, so we do not read it as death.
+    const refreshLive = hasRefresh && (refreshExpiry === undefined || refreshExpiry > now);
+    // Report the date this login actually dies on, not the one that moves every
+    // eight hours: a panel reading "token until <today>" is alarming and wrong.
+    // Only while the refresh token is the operative one, though — a live access
+    // token beside a dead refresh token dies on its OWN date. And when the CLI
+    // recorded no date for a live refresh token we say NOTHING: printing the
+    // access token's lapsed date beside the word «signed in» is the very screen
+    // this function's docblock promises not to draw (QA-117 M3).
+    const effectiveExpiry = refreshLive ? refreshExpiry : accessExpiry;
+    const expiresAt = effectiveExpiry === undefined ? undefined : new Date(effectiveExpiry).toISOString();
+    if (!accessLive && !refreshLive) {
+        return (fallbackToken() ?? {
+            status: 'expired',
+            ...(expiresAt ? { expiresAt } : {}),
+            detail: 'the stored login has expired',
+        });
+    }
+    return {
+        status: 'ok',
+        ...(expiresAt ? { expiresAt } : {}),
+        // Only a plain string, and only a short one: this value is read off disk
+        // and printed in every member's panel.
+        ...(isNonEmptyString(oauth.subscriptionType)
+            ? { detail: `subscription ${oauth.subscriptionType.slice(0, 40)}` }
+            : {}),
+    };
+}
+// ─── What the agent actually experienced ─────────────────────────────
+//
+// The credentials file cannot tell us the provider revoked this login: the
+// refresh token still sits there, dated. The one authority on that is a real
+// refusal from a real run — so a session that failed to authenticate demotes
+// the file's verdict for a while, and any successful turn clears it again.
+//
+// Process memory on purpose: no protocol, no disk. The consequence is worth
+// naming — restarting the daemon forgets the refusal and the panel goes back
+// to trusting the file until the next session tries.
+const AUTH_FAILURE_TTL_MS = 15 * 60_000;
+const authFailures = new Map();
+/** A session just failed to authenticate as this agent. */
+export function noteAgentAuthFailure(agent) {
+    authFailures.set(agent, Date.now());
+    log.warn('auth-relay: agent sign-in refused during a session', { agent });
+    // A refusal is the only authority on a revoked credential, and a token we
+    // captured ourselves has no other expiry we can see. Keeping it would let a
+    // dead login outlive the evidence: the failure marker times out after 15
+    // minutes and the panel would go green again over the same dead token.
+    if (agent === 'claude' && storedClaudeToken()) {
+        clearStoredClaudeToken();
+        log.warn('auth-relay: discarded the stored Claude token after a refusal');
+    }
+}
+/** The agent just worked — whatever was wrong with the sign-in is not. */
+export function clearAgentAuthFailure(agent) {
+    if (authFailures.delete(agent)) {
+        log.info('auth-relay: agent sign-in is working again', { agent });
     }
 }
+/**
+ * Is a refusal still being held against this agent?
+ *
+ * Exported so the wiring in `supervisor.ts` can be pinned by a test without
+ * shelling out to the agent CLIs: this predicate IS the mechanism the panel's
+ * demotion reads, and three unguarded lines were carrying it (QA-117 M6).
+ */
+export function agentAuthFailureActive(agent) {
+    return hasRecentAuthFailure(agent);
+}
+function hasRecentAuthFailure(agent) {
+    const at = authFailures.get(agent);
+    if (at === undefined)
+        return false;
+    if (Date.now() - at > AUTH_FAILURE_TTL_MS) {
+        authFailures.delete(agent);
+        return false;
+    }
+    return true;
+}
+/** Last verdict we published per agent — logged only when it changes. */
+const lastVerdict = new Map();
+function logVerdictChange(agent, status) {
+    const previous = lastVerdict.get(agent);
+    if (previous === status.status)
+        return;
+    lastVerdict.set(agent, status.status);
+    // Without this line there is no way to confirm on a live server that the
+    // verdict changed — and no way to see it flapping (lesson from #103).
+    log.info('auth-relay: login verdict', {
+        agent,
+        from: previous ?? 'none',
+        to: status.status,
+        ...(status.expiresAt ? { expiresAt: status.expiresAt } : {}),
+    });
+}
 /**
  * Codex reports its own login state via an exit code (0 signed in / 1 not).
  * Probed against the RUNNER's home: the host user can be signed in while our
@@ -282,8 +660,28 @@ function readCodexCredential(homePath) {
         return null;
     }
 }
+/**
+ * A verdict read off disk, overruled by what a real session experienced.
+ *
+ * Only ever downgrades: a refusal we witnessed outranks a file that looks fine,
+ * and never the other way round — a file saying `expired` is not made `ok` by
+ * the absence of failures.
+ */
+function withObservedFailures(agent, status) {
+    if (status.status !== 'ok' || !hasRecentAuthFailure(agent))
+        return status;
+    return {
+        status: 'expired',
+        ...(status.expiresAt ? { expiresAt: status.expiresAt } : {}),
+        detail: 'the agent was refused with this sign-in — re-login needed',
+    };
+}
 export async function agentAuthStatuses() {
-    const [claude, codex] = await Promise.all([claudeAuthStatus(), codexAuthStatus()]);
+    const [claudeRaw, codexRaw] = await Promise.all([claudeAuthStatus(), codexAuthStatus()]);
+    const claude = withObservedFailures('claude', claudeRaw);
+    const codex = withObservedFailures('codex', codexRaw);
+    logVerdictChange('claude', claude);
+    logVerdictChange('codex', codex);
     return { claude, codex };
 }
 //# sourceMappingURL=auth-relay.js.map