@ctrl-spc/cs 0.7.14 → 0.7.16

package/dist/daemon.js

@@ -1,49 +1,17 @@
-import { ensureAutostart } from './autostart.js';
-import { liveClient, startPresence, stopPresence } from './presence.js';
-/**
- * The terminal presence daemon (`cs start`). Comes online and heartbeats until
- * the process is signalled. Under launchd/KeepAlive (autostart) a hard crash is
- * restarted by the OS. The companion server (`cs open`) shares the same presence
- * loop via presence.ts, so the two front-ends never diverge.
- *
- * ═══ AND SINCE recovery-1 SLICE 4 IT ALSO ANSWERS AGENT PANEL CARDS. ═══ Lane's
- * ruling (2026-08-21): *the user experience must never require them to launch or
- * authenticate multiple CLIs. They launch the CLI with `cs start`.* Before this
- * the panel was a second binary with a second sign-in, so a stranded card could
- * name the right machine and print a command that started the wrong daemon.
- *
- * THE PANEL GETS THE SESSION THIS ALREADY HOLDS, never one of its own. Two
- * clients in one process is two refresh loops on one rotating refresh token,
- * both writing `session.json`.
- *
- * Companion and the terminal daemon both use the same presence lifecycle,
- * which owns the card worker, session and per-machine lock.
- */
+import { inspectLocalRuntime, startLocalRuntime, stopLocalOwnerForSignal } from './daemon-lifecycle.js';
+import { CLI_VERSION } from './package-version.js';
+import { machineHostname } from './config.js';
+/** Foreground entry; local lifecycle owns service control and cloud reconnects. */
 export async function runDaemon() {
-    const { machineName, agents } = await startPresence();
-    ensureAutostart(); // default-on: install the login item unless the user opted out
-    console.log(`CTRL+SPC — this computer: ${machineName}`);
-    console.log(`Agents detected: ${agents.length ? agents.join(', ') : 'none'}`);
-    console.log('Online. Heartbeating presence and answering cards. Ctrl-C to stop.');
-    let stopping = false;
-    async function shutdown(code = 0) {
-        if (stopping)
-            return;
-        stopping = true;
-        // Shared presence stops the card worker and both readiness records.
-        await stopPresence();
-        process.exit(code);
+    if (!await startLocalRuntime()) {
+        const current = await inspectLocalRuntime();
+        console.log(`CTRL+SPC is already running on ${machineHostname()} (pid ${current?.record.process.pid ?? 'unknown'}).`);
+        console.log(`Running version: ${current?.status?.version ?? 'unavailable'}. Installed version: ${CLI_VERSION}.`);
+        console.log('Use cs status to check it, cs stop to stop it, or cs restart to load this installed version.');
+        return;
     }
-    process.on('SIGINT', () => void shutdown());
-    process.on('SIGTERM', () => void shutdown());
-    // Presence owns sign-out cleanup; the terminal entry also exits.
-    const live = liveClient();
-    if (!live)
-        throw new Error('the presence loop is not running, so there is no session to watch');
-    live.auth.onAuthStateChange((event) => {
-        if (event === 'SIGNED_OUT')
-            void shutdown(1);
-    });
-    // Keep the event loop alive.
-    await new Promise(() => { });
+    console.log(`CTRL+SPC is running on ${machineHostname()}. Loaded version: ${CLI_VERSION}.`);
+    console.log('Cloud connection is being checked. Run cs status for readiness. Use cs stop or cs restart to manage this service.');
+    process.on('SIGINT', () => void stopLocalOwnerForSignal().catch((error) => console.error(error.message)));
+    process.on('SIGTERM', () => void stopLocalOwnerForSignal().catch((error) => console.error(error.message)));
 }

package/dist/darwin-coalition.js

@@ -0,0 +1,340 @@
+import { spawn, execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promisify } from 'node:util';
+import { chmodSync, existsSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createServer, createConnection } from 'node:net';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const execute = promisify(execFile);
+const modulePath = fileURLToPath(import.meta.url);
+const executable = join(dirname(modulePath), 'native', 'darwin-coalition');
+export function validMacCoalition(value) {
+    const v = value;
+    return !!v && /^\d+$/.test(v.id) && /^[\da-f-]{36}$/i.test(v.boot) && /^com\.ctrl-spc\.execution\.[\da-f-]{36}$/i.test(v.label)
+        && (v.domain === undefined || v.domain === 'gui' || v.domain === 'user');
+}
+function timeout(deadline) {
+    if (Date.now() >= deadline)
+        throw new Error('Service operation exceeded its deadline.');
+    return Math.max(1, Math.min(5000, deadline - Date.now()));
+}
+async function native(args, deadline = Date.now() + 5000) {
+    for (;;) {
+        try {
+            const { stdout } = await execute(executable, args, { timeout: timeout(deadline), maxBuffer: 8 * 1024 * 1024 });
+            return stdout.trim() ? JSON.parse(stdout) : null;
+        }
+        catch (error) {
+            // A fork/exit between enumeration and the atomic count is a known,
+            // read-only race. Retry only this result within the caller's deadline.
+            if (error.code !== 75 || Date.now() + 25 >= deadline) {
+                // Preparation failures can become cloud-visible text. execFile's own
+                // message embeds local executable paths; the helper's fixed messages
+                // contain only the operation and OS error number.
+                const detail = error.stderr;
+                throw new Error(typeof detail === 'string' && detail.trim() ? detail.trim().slice(0, 500)
+                    : 'Mac execution ownership could not be verified. Reinstall CTRL+SPC or retry the command.', { cause: error });
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+}
+async function processCoalition(pid, deadline) {
+    const value = await native(['process', String(pid)], deadline);
+    if (value === null)
+        return null;
+    if (!value || typeof value.id !== 'string' || !/^\d+$/.test(value.id) || typeof value.boot !== 'string' || !/^[\da-f-]{36}$/i.test(value.boot)
+        || value.pid !== pid || value.owner !== process.getuid())
+        throw new Error('Mac execution identity is unavailable.');
+    return value;
+}
+export async function inspectMacCoalition(coalition, deadline = Date.now() + 5000) {
+    if (!validMacCoalition(coalition))
+        throw new Error('Mac execution identity is invalid.');
+    const result = await native(['inspect', coalition.id, coalition.boot], deadline);
+    if (!result || typeof result.exists !== 'boolean' || !Number.isSafeInteger(result.active) || result.active < 0 || !Array.isArray(result.members))
+        throw new Error('Mac execution membership is unavailable.');
+    const rows = result.members.map((row) => nativeIdentity(row, coalition));
+    if (result.active > rows.length || (result.active === 0 && rows.length))
+        throw new Error('Mac execution membership changed. Retry the command.');
+    return rows;
+}
+function nativeIdentity(row, coalition) {
+    if (!row || !Number.isInteger(row.pid) || row.pid <= 0 || !Number.isInteger(row.ppid) || !Number.isInteger(row.pgid)
+        || row.owner !== String(process.getuid()) || typeof row.birth !== 'string' || !Number.isFinite(Date.parse(row.birth))
+        || !Number.isInteger(row.version) || row.version <= 0)
+        throw new Error('Mac process identity is invalid.');
+    return { pid: row.pid, ppid: row.ppid, pgid: row.pgid, owner: row.owner, birth: row.birth,
+        commandHash: createHash('sha256').update(`${row.pid}:${row.version}`).digest('hex'), macProcessVersion: row.version, ...(coalition ? { macCoalition: coalition } : {}) };
+}
+export async function inspectMacProcess(pid, deadline) {
+    const result = await native(['process', String(pid)], deadline);
+    if (result === null)
+        return null;
+    return nativeIdentity({ ...result, owner: String(result.owner) });
+}
+export async function inspectMacProcesses(deadline) {
+    const result = await native(['all'], deadline);
+    if (!result || !Array.isArray(result.members))
+        throw new Error('Mac process enumeration is unavailable.');
+    return result.members.map((row) => nativeIdentity(row));
+}
+export async function signalMacMember(identity, deadline, signal = 'KILL') {
+    if (!identity.macCoalition || !identity.macProcessVersion)
+        throw new Error('Mac process ownership is unavailable.');
+    await native(['signal', identity.macCoalition.id, identity.macCoalition.boot, String(identity.pid), String(identity.macProcessVersion), signal], deadline);
+}
+export async function signalMacProcess(identity, deadline) {
+    if (identity.owner !== String(process.getuid()))
+        throw new Error('Mac process belongs to another user.');
+    const own = await processCoalition(process.pid, deadline);
+    if (!own)
+        throw new Error('Mac process signaling is unavailable.');
+    await native(['signal-process', own.boot, String(identity.pid), identity.birth], deadline);
+}
+export async function unloadMacExecution(coalition, deadline) {
+    if (!validMacCoalition(coalition))
+        throw new Error('Mac execution identity is invalid.');
+    // Only the first unpublished candidate omitted this field and used gui.
+    // Never try both namespaces: the recorded one is the only owned job.
+    try {
+        await execute('/bin/launchctl', ['bootout', `${coalition.domain ?? 'gui'}/${process.getuid()}/${coalition.label}`], { timeout: timeout(deadline) });
+    }
+    catch (error) {
+        if (![3, 113].includes(error.code ?? -1))
+            throw new Error('The owned Mac execution job could not be unloaded.', { cause: error });
+    }
+}
+export function spawnMacExecution(bin, args, options, reservationId, file) {
+    if (!existsSync(executable))
+        throw new Error('The Mac execution helper is missing. Reinstall CTRL+SPC before starting work.');
+    if (!/^[\da-f-]{36}$/i.test(reservationId))
+        throw new Error('Invalid execution reservation.');
+    // A private short path avoids sockaddr_un's path limit for long config dirs.
+    const directory = mkdtempSync(`/tmp/ctrl-spc-execution-${process.getuid()}-`);
+    chmodSync(directory, 0o700);
+    const access = statSync(directory);
+    if (access.uid !== process.getuid() || (access.mode & 0o777) !== 0o700)
+        throw new Error('Mac execution transport could not be made private.');
+    const ready = join(directory, 'ready.json');
+    const launch = { bin, args, cwd: options.cwd?.toString() ?? process.cwd(), env: options.env ?? process.env,
+        shell: options.shell ?? false, label: `com.ctrl-spc.execution.${reservationId}`, domain: 'user', directory, ready };
+    try {
+        writeFileSync(file, JSON.stringify(launch), { flag: 'wx', mode: 0o600 });
+        return { child: spawn(process.execPath, [modulePath, '--bridge', file], { ...options, shell: false, detached: true }), ready };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        rmSync(file, { force: true });
+        throw error;
+    }
+}
+export function readMacExecution(ready) {
+    let text;
+    try {
+        text = readFileSync(ready, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    const result = JSON.parse(text);
+    if (!validMacCoalition(result))
+        throw new Error('Mac execution identity is invalid.');
+    return result;
+}
+export function removeMacExecutionFiles(ready) { rmSync(dirname(ready), { recursive: true, force: true }); }
+function send(socket, frame, source) {
+    if (!socket.write(JSON.stringify(frame) + '\n') && source) {
+        source.pause();
+        socket.once('drain', () => source.resume());
+    }
+}
+function frames(socket, receive) {
+    let pending = '';
+    socket.setEncoding('utf8');
+    socket.on('data', (chunk) => {
+        pending += chunk;
+        if (pending.length > 2 * 1024 * 1024) {
+            socket.destroy(new Error('Mac execution transport exceeded its frame limit.'));
+            return;
+        }
+        let end;
+        while ((end = pending.indexOf('\n')) >= 0) {
+            const line = pending.slice(0, end);
+            pending = pending.slice(end + 1);
+            try {
+                receive(JSON.parse(line));
+            }
+            catch {
+                socket.destroy(new Error('Mac execution transport is invalid.'));
+                return;
+            }
+        }
+    });
+}
+function xml(text) { return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'); }
+async function bridge(file) {
+    const launch = JSON.parse(readFileSync(file, 'utf8'));
+    const own = await processCoalition(process.pid);
+    if (!own)
+        throw new Error('Mac execution capability is unavailable; no agent was started.');
+    const socketPath = join(launch.directory, 'io.sock'), plist = join(launch.directory, 'job.plist');
+    let socket = null, connected = false, ended = false, exitReceived = false;
+    let jobIdentity = null;
+    process.stdin.pause();
+    const server = createServer((peer) => {
+        if (connected) {
+            peer.destroy();
+            return;
+        }
+        connected = true;
+        socket = peer;
+        peer.on('error', () => { process.exitCode = 1; });
+        peer.on('close', () => {
+            if (!exitReceived)
+                process.exitCode = 1;
+            process.stdin.destroy();
+            if (!exitReceived)
+                server.close();
+        });
+        frames(peer, (frame) => {
+            if (frame.kind === 'hello' && typeof frame.pid === 'number') {
+                void (async () => {
+                    const identity = await processCoalition(frame.pid);
+                    if (!identity || identity.id === own.id)
+                        throw new Error('The Mac execution job is not isolated.');
+                    const coalition = { id: identity.id, boot: identity.boot, label: launch.label, domain: launch.domain };
+                    const members = await inspectMacCoalition(coalition);
+                    if (members.length !== 1 || members[0].pid !== frame.pid)
+                        throw new Error('The Mac execution job is not exclusively owned.');
+                    jobIdentity = members[0];
+                    const temp = launch.ready + '.tmp';
+                    writeFileSync(temp, JSON.stringify(coalition), { flag: 'wx', mode: 0o600 });
+                    renameSync(temp, launch.ready);
+                    process.stdin.on('data', (chunk) => send(peer, { kind: 'stdin', data: chunk.toString('base64') }, process.stdin));
+                    process.stdin.on('end', () => { ended = true; send(peer, { kind: 'end' }); });
+                    process.stdin.resume();
+                })().catch(() => { console.error('The Mac execution job could not be safely registered.'); process.exitCode = 1; peer.destroy(); });
+            }
+            else if ((frame.kind === 'stdout' || frame.kind === 'stderr') && typeof frame.data === 'string') {
+                const output = frame.kind === 'stdout' ? process.stdout : process.stderr;
+                if (!output.write(Buffer.from(frame.data, 'base64'))) {
+                    peer.pause();
+                    output.once('drain', () => peer.resume());
+                }
+            }
+            else if (frame.kind === 'exit' && typeof frame.code === 'number') {
+                exitReceived = true;
+                process.exitCode = frame.code;
+                peer.end();
+                process.stdin.destroy();
+                void (async () => {
+                    const deadline = Date.now() + 5000;
+                    while (jobIdentity && Date.now() < deadline) {
+                        const current = await inspectMacProcess(jobIdentity.pid, deadline);
+                        if (!current || current.birth !== jobIdentity.birth)
+                            return;
+                        await new Promise((resolve) => setTimeout(resolve, 10));
+                    }
+                    if (jobIdentity)
+                        throw new Error('Mac execution helper did not close.');
+                })().catch(() => { process.exitCode = 1; }).finally(() => server.close());
+            }
+            else
+                throw new Error('Invalid execution transport frame.');
+        });
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(socketPath, resolve); });
+    const content = '<?xml version="1.0"?><plist version="1.0"><dict><key>Label</key><string>' + launch.label + '</string>'
+        + '<key>ProgramArguments</key><array>' + [process.execPath, modulePath, '--job', file, launch.domain].map((value) => '<string>' + xml(value) + '</string>').join('') + '</array>'
+        + '<key>LimitLoadToSessionType</key><string>Background</string><key>RunAtLoad</key><true/><key>KeepAlive</key><false/><key>AbandonProcessGroup</key><true/></dict></plist>';
+    writeFileSync(plist, content, { flag: 'wx', mode: 0o600 });
+    try {
+        await execute('/bin/launchctl', ['bootstrap', `${launch.domain}/${process.getuid()}`, plist], { timeout: 5000 });
+    }
+    catch (error) {
+        socket?.destroy();
+        server.close();
+        throw error;
+    }
+    // Only bootstrap/registration is bounded. Running agents have no timer.
+    const timer = setTimeout(() => { if (!existsSync(launch.ready)) {
+        console.error('The Mac execution job did not become ready.');
+        process.exitCode = 1;
+        socket?.destroy();
+        server.close();
+    } }, 5000);
+    timer.unref();
+    process.on('exit', () => { if (!ended)
+        process.stdin.destroy(); });
+}
+function job(file) {
+    const closeUnpromptedJob = (label, domain = process.argv[4] === 'user' ? 'user' : 'gui') => {
+        if (!label || !/^com\.ctrl-spc\.execution\.[\da-f-]{36}$/i.test(label))
+            return;
+        // The creator can disappear before this queued job even reads its launch
+        // file. No grant can then arrive; remove this exact one-shot job as well.
+        void execute('/bin/launchctl', ['bootout', `${domain}/${process.getuid()}/${label}`], { timeout: 5000 }).catch(() => { process.exitCode = 1; });
+    };
+    let launch;
+    try {
+        launch = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        closeUnpromptedJob(process.env.XPC_SERVICE_NAME);
+        process.exitCode = 1;
+        return;
+    }
+    const socket = createConnection(join(launch.directory, 'io.sock'));
+    let provider = null, admitted = false;
+    socket.on('connect', () => send(socket, { kind: 'hello', pid: process.pid }));
+    socket.on('error', () => { if (!admitted)
+        process.exitCode = 1; });
+    socket.on('close', () => { if (!admitted)
+        closeUnpromptedJob(launch.label, launch.domain ?? 'gui'); });
+    frames(socket, (frame) => {
+        if (frame.kind === 'stdin' && typeof frame.data === 'string') {
+            let bytes = Buffer.from(frame.data, 'base64');
+            if (!admitted) {
+                if (!bytes.length || bytes[0] !== 1)
+                    throw new Error('Invalid execution grant.');
+                admitted = true;
+                bytes = bytes.subarray(1);
+                provider = spawn(launch.bin, launch.args, { cwd: launch.cwd, env: launch.env, shell: launch.shell, stdio: ['pipe', 'pipe', 'pipe'] });
+                provider.stdin?.on('error', () => { });
+                provider.stdout?.on('data', (chunk) => { if (!socket.destroyed)
+                    send(socket, { kind: 'stdout', data: chunk.toString('base64') }, provider.stdout); });
+                provider.stderr?.on('data', (chunk) => { if (!socket.destroyed)
+                    send(socket, { kind: 'stderr', data: chunk.toString('base64') }, provider.stderr); });
+                provider.on('error', () => { if (!socket.destroyed)
+                    send(socket, { kind: 'stderr', data: Buffer.from('The harness could not start.').toString('base64') }); });
+                provider.on('close', (code, signal) => { if (!socket.destroyed) {
+                    send(socket, { kind: 'exit', code: code ?? 1, signal });
+                    socket.end();
+                } });
+            }
+            if (bytes.length && !provider?.stdin?.write(bytes)) {
+                socket.pause();
+                provider?.stdin?.once('drain', () => socket.resume());
+            }
+        }
+        else if (frame.kind === 'end') {
+            if (provider)
+                provider.stdin?.end();
+            else {
+                send(socket, { kind: 'exit', code: 0 });
+                socket.end();
+            }
+        }
+        else
+            throw new Error('Invalid execution transport frame.');
+    });
+}
+if (process.argv[1] === modulePath) {
+    if (process.argv[2] === '--bridge')
+        void bridge(process.argv[3]).catch(() => { console.error('Mac safe execution is unavailable; no agent was started.'); process.exitCode = 1; });
+    else if (process.argv[2] === '--job')
+        job(process.argv[3]);
+}

package/dist/failure-reason.js

@@ -64,22 +64,8 @@ export function plainFailureReason(agent, error, stderr = '') {
         || haystack.includes('429') || haystack.includes('overloaded')) {
         return `${name}'s usage limit is in effect on this account, so the run could not start.`;
     }
-    /* SIGNED OUT. Recoverable by the user, and silent otherwise: the run just
-       fails, over and over, for as long as the session is stale.
-  
-       18a SLICE 7 ADDED THE OAUTH AND 401 SIGNATURES, from the real thing rather
-       than from imagination. The Windows machine's Claude Code had a stale token
-       and said, on STDOUT as a stream-json result: `"error":
-       "authentication_failed"` and `API Error: 401 OAuth access token has
-       expired.` The word "authentication" above would have matched that, but only
-       once stdout was being read at all, which is the other half of the fix. `401`
-       and `oauth` are here so the same failure is caught when it arrives in
-       shorter words. */
-    if (haystack.includes('unauthorized') || haystack.includes('not logged in')
-        || haystack.includes('authentication') || haystack.includes('oauth')
-        || haystack.includes('401')) {
-        return `${name} is not signed in on this machine.`;
-    }
+    if (nativeFailureKind(stderr, error) === 'authentication')
+        return failureMessage(agent, 'authentication');
     /* THE RUN WAS KILLED, by the timeout or by a signal from outside. Not the
        user's Stop, which never reaches here: a stopped run is settled with its own
        flag well before this. */
@@ -96,3 +82,77 @@ export function plainFailureReason(agent, error, stderr = '') {
     }
     return `${name} stopped without finishing.`;
 }
+/** Accept only native error records and verified diagnostic lines. Assistant
+ * prose, a quoted status code and credential-file presence prove nothing. */
+export function nativeFailureKind(output, diagnostics = '') {
+    const classify = (value) => {
+        if (!value || typeof value !== 'object')
+            return 'unknown';
+        const record = value;
+        const nested = record.error;
+        const error = nested && typeof nested === 'object' ? nested : record;
+        const code = typeof error.code === 'string' ? error.code : typeof nested === 'string' ? nested : typeof error.type === 'string' ? error.type : '';
+        if (['authentication_error', 'authentication_failed', 'invalid_api_key', 'invalid_authentication', 'token_expired', 'refresh_token_expired', 'refresh_token_reused', 'refresh_token_invalidated'].includes(code))
+            return 'authentication';
+        if (['rate_limit_error', 'rate_limit_exceeded', 'usage_limit_reached', 'insufficient_quota'].includes(code))
+            return 'usage-limit';
+        if (code === 'invalid_request_error' && record.status === 400 && typeof error.message === 'string' && /^The requested model is not supported for this account\.?$/.test(error.message))
+            return 'invalid-model';
+        if (['model_not_found', 'unsupported_model', 'unrecognized_model'].includes(code))
+            return 'invalid-model';
+        if (['overloaded_error', 'server_error', 'temporarily_unavailable', 'connection_error'].includes(code))
+            return 'transient';
+        if (typeof error.message === 'string') {
+            if (error.message === 'Your access token could not be refreshed. Please log out and sign in again.')
+                return 'authentication';
+            try {
+                return classify(JSON.parse(error.message));
+            }
+            catch { /* Not a nested native record. */ }
+        }
+        return 'unknown';
+    };
+    for (const line of output.split('\n')) {
+        const text = line.trim();
+        try {
+            const event = JSON.parse(text);
+            // Ignore native assistant messages, tool results and their quoted prose.
+            if (['turn.failed', 'error'].includes(event?.type) || (event?.type === 'result' && event.is_error === true)) {
+                if (event.type === 'result' && (event.api_error_status === undefined || event.api_error_status === 401)
+                    && event.result === 'Failed to authenticate. API Error: 401 Invalid bearer token')
+                    return 'authentication';
+                if (event.type === 'result' && event.api_error_status === 401 && typeof event.result === 'string'
+                    && /^Failed to authenticate\. API Error: 401 OAuth access token (?:has (?:expired|been revoked)|is invalid)\./.test(event.result))
+                    return 'authentication';
+                const kind = classify(event);
+                if (kind !== 'unknown')
+                    return kind;
+            }
+        }
+        catch { /* Native diagnostics may be non-JSON. */ }
+    }
+    for (const text of diagnostics.split('\n').map(line => line.trim())) {
+        if (/^API Error: (529|503) (Overloaded|Service unavailable)$/.test(text))
+            return 'transient';
+        if (/^API Error: 401 (?:OAuth access token (?:has (?:expired|been revoked)|is invalid)\.|.*"type"\s*:\s*"authentication_error")/.test(text)
+            || /^\[claude-code:authentication_failed\]/.test(text)
+            || /^ERROR: Your access token could not be refreshed because your refresh token was already used\./.test(text))
+            return 'authentication';
+        if (/^\[claude-code:unrecognized_model\]/.test(text))
+            return 'invalid-model';
+    }
+    return 'unknown';
+}
+export function failureMessage(agent, kind) {
+    const name = agentDisplayName(agent);
+    switch (kind) {
+        case 'authentication': return `${name} needs sign-in on its assigned computer. Saved work is waiting for you to restart this card.`;
+        case 'preparation-unavailable': return `${name}'s local credentials or execution configuration could not be checked.`;
+        case 'missing-binary': return `${name} is not installed on this machine, or is not on its PATH.`;
+        case 'timeout': return 'The run was stopped for taking too long.';
+        case 'usage-limit': return `${name}'s usage limit is in effect on this account.`;
+        case 'invalid-model': return `${name} rejected the selected model. Choose an available model and retry.`;
+        case 'transient': return `${name}'s service is temporarily unavailable.`;
+        default: return `${name} stopped without finishing.`;
+    }
+}