@ctrl-spc/cs 0.7.15 → 0.7.16

package/dist/daemon-lifecycle.js

@@ -1,19 +1,20 @@
+import { sessionRenewing } from './supabase.js';
 import { createServer } from 'node:http';
-import { randomUUID, timingSafeEqual, createHash } from 'node:crypto';
+import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync, openSync, closeSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { configDir, getMachineIdentity, lifecycleToken, readLifecycleToken, readMcpToken, readSession, machineHostname } from './config.js';
+import { configDir, getMachineIdentity, lifecycleToken, readLifecycleToken, readMcpToken, readSessionRecord, machineHostname } from './config.js';
 import { entryPath, ensureAutostart, prepareAutostart, autostartDisabled, autostartEnabled, loadedStartupJob, unloadStoppedStartupJob } from './autostart.js';
 import { CLI_VERSION } from './package-version.js';
 import { TOOLS_SERVER_PORT } from './env.js';
 import { claimLifecycleOperation, publishRuntime, readMigration, readOperation, readRuntime, removeOperation, removeRuntime, updateOperation, updateRuntime, writeMigration } from './daemon-lock.js';
 import { inspectProcess, processIdentityMatches, osBootIdentity, loopbackListenerPid, terminateOwnedRoot } from './win-shell.js';
 import { initializeOwnedWork, snapshotOwnedWork, interruptOwnedWork, markOwnedWorkInterrupted, ownedWorkInstanceNonces } from './daemon-processes.js';
-import { startPresence, stopPresence, liveClient, suspendPresenceWork, resumePresenceWork, presenceCloudState } from './presence.js';
+import { startPresence, stopPresence, liveClient, suspendPresenceWork, resumePresenceWork, presenceCloudState, observePresenceSession } from './presence.js';
 import { NotLoggedIn } from './supabase.js';
 import { launchWindowsService, windowsJobExecutable } from './windows-job.js';
 const MAX_COMMAND_MS = 30_000;
@@ -42,8 +43,7 @@ async function bounded(promise, deadline) {
     }
 }
 function sessionFingerprint() {
-    const session = readSession();
-    return session ? createHash('sha256').update(JSON.stringify(session)).digest('hex') : 'none';
+    return readSessionRecord()?.generation ?? 'none';
 }
 function pendingExecution(work) {
     const claims = new Set((work.claimPending ?? []).map((item) => item.id));
@@ -82,6 +82,20 @@ export async function inspectLocalRuntime(deadline = Date.now() + 10_000) {
         return { record, status: null };
     } // Verified local owner is alive; readiness remains unknown.
 }
+/** Acknowledgment means admission is closed, not merely that credentials were deleted. */
+export async function notifySessionChanged() {
+    const deadline = Date.now() + 5000;
+    if (runtime) {
+        await bounded(observePresenceSession(), deadline);
+        return;
+    }
+    const current = await inspectLocalRuntime(deadline);
+    if (!current)
+        return;
+    if (!current.status)
+        throw new Error('Sign-in changed locally, but the running service did not confirm it. Check this computer in Companion.');
+    await control(current.record, 'session-changed', deadline);
+}
 async function verifiedLegacyOwner(deadline) {
     const token = readMcpToken();
     if (!token)
@@ -188,22 +202,29 @@ let signalController = null;
 async function runtimeStatus(deadline = Date.now() + 8000) {
     if (!runtime)
         throw new Error('This process does not own the local service.');
-    return { nonce: runtime.record.nonce, pid: process.pid, version: CLI_VERSION, local: runtime.record.state, cloud: presenceCloudState(), work: await snapshotOwnedWork(deadline) };
+    return { nonce: runtime.record.nonce, pid: process.pid, version: CLI_VERSION, local: runtime.record.state, cloud: presenceCloudState(), sessionRenewing: sessionRenewing(), work: await snapshotOwnedWork(deadline) };
 }
 async function connectCloud() {
-    if (!runtime || runtime.record.state === 'stopping' || connecting || liveClient())
-        return;
-    if (rejectedSession === sessionFingerprint())
+    if (!runtime || runtime.record.state === 'stopping' || connecting)
         return;
     connecting = (async () => {
         try {
+            await observePresenceSession();
+            if (liveClient())
+                return;
+            if (rejectedSession === sessionFingerprint())
+                return;
             await startPresence();
             rejectedSession = null;
         }
         catch (error) {
-            if (error instanceof NotLoggedIn)
-                rejectedSession = sessionFingerprint();
-            console.warn(error instanceof NotLoggedIn ? 'Cloud sign-in is required. Local service controls remain available.' : 'Cloud connection is unavailable. Local service controls remain available.');
+            if (error instanceof NotLoggedIn) {
+                try {
+                    rejectedSession = sessionFingerprint();
+                }
+                catch { /* Storage failures remain unavailable. */ }
+            }
+            console.warn(error instanceof NotLoggedIn ? 'Cloud sign-in is required. Local service controls remain available.' : 'Cloud connection or local sign-in storage is unavailable. Local service controls remain available.');
         }
     })();
     try {
@@ -354,6 +375,12 @@ export async function startLocalRuntime({ onStop } = {}) {
                     res.end(JSON.stringify(await runtimeStatus()));
                     return;
                 }
+                if (req.url === '/session-changed' && req.method === 'POST') {
+                    await observePresenceSession();
+                    res.end(JSON.stringify(await runtimeStatus(Date.now() + 3000)));
+                    void connectCloud().catch(() => { }); // The resident reconnect loop retains failed startup.
+                    return;
+                }
                 if (req.url !== '/stop' || req.method !== 'POST' || req.headers['content-type'] !== 'application/json') {
                     res.writeHead(405);
                     res.end(JSON.stringify({ error: 'Unsupported local control action.' }));

package/dist/daemon-processes.js

@@ -13,6 +13,7 @@ const claimWaiters = new Set();
 const admissionWaiters = new Set();
 const handles = new Map();
 const creating = new Set();
+const preparing = new Set();
 function path() { return join(lifecycleDir(), 'owned-work.json'); }
 function record(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
 function identity(value) {
@@ -32,6 +33,8 @@ function reference(value) {
         return typeof value.runId === 'string' && typeof value.cardId === 'string'
             && (value.processToken === null || typeof value.processToken === 'string') && typeof value.startedAt === 'string'
             && (value.resumedAt === null || typeof value.resumedAt === 'string') && ids(value.observedPendingTurnIds)
+            && (value.authRecoveryRunId === undefined || value.authRecoveryRunId === null || typeof value.authRecoveryRunId === 'string')
+            && (value.harness === undefined || value.harness === null || ['codex', 'claude'].includes(String(value.harness)))
             && (value.pid === undefined || value.pid === null || Number.isInteger(value.pid) && value.pid > 0);
     if (value.surface === 'worker')
         return typeof value.todoId === 'string' && (value.workerId === null || typeof value.workerId === 'string')
@@ -46,7 +49,7 @@ function readStore() {
     if (!existsSync(path()))
         return { version: 1, entries: [], legacy: [] };
     const value = JSON.parse(readFileSync(path(), 'utf8'));
-    if (!record(value) || (value.legacyBootstrap !== undefined && typeof value.legacyBootstrap !== 'boolean') || (value.rpcClaims !== undefined && (!Array.isArray(value.rpcClaims) || !value.rpcClaims.every((row) => record(row) && typeof row.id === 'string' && ['panel', 'cli'].includes(String(row.surface)) && typeof row.action === 'string' && typeof row.accountId === 'string' && typeof row.machineId === 'string' && typeof row.instanceNonce === 'string'))) || value.version !== 1 || !Array.isArray(value.entries) || !Array.isArray(value.legacy)
+    if (!record(value) || (value.mcpCleanup !== undefined && (!Array.isArray(value.mcpCleanup) || !value.mcpCleanup.every(row => record(row) && typeof row.accountId === 'string' && typeof row.sessionId === 'string'))) || (value.legacyBootstrap !== undefined && typeof value.legacyBootstrap !== 'boolean') || (value.rpcClaims !== undefined && (!Array.isArray(value.rpcClaims) || !value.rpcClaims.every((row) => record(row) && typeof row.id === 'string' && ['panel', 'cli'].includes(String(row.surface)) && typeof row.action === 'string' && typeof row.accountId === 'string' && typeof row.machineId === 'string' && typeof row.instanceNonce === 'string' && (row.args === undefined || record(row.args)) && (row.result === undefined || Array.isArray(row.result))))) || value.version !== 1 || !Array.isArray(value.entries) || !Array.isArray(value.legacy)
         || !value.entries.every((entry) => record(entry) && typeof entry.id === 'string'
             && typeof entry.accountId === 'string' && typeof entry.machineId === 'string' && typeof entry.instanceNonce === 'string'
             && (entry.harness === null || typeof entry.harness === 'string') && (entry.reference === null || reference(entry.reference))
@@ -58,6 +61,16 @@ function readStore() {
             && (entry.gatedCreation === undefined || typeof entry.gatedCreation === 'boolean')
             && (entry.windowsJob === undefined || typeof entry.windowsJob === 'string')
             && (entry.rawPid === undefined || Number.isInteger(entry.rawPid) && entry.rawPid > 0)
+            && (entry.terminalOutcome === undefined || record(entry.terminalOutcome) && ['panel', 'worker', 'reply'].includes(String(entry.terminalOutcome.surface)) && typeof entry.terminalOutcome.ok === 'boolean' && (entry.terminalOutcome.text === null || typeof entry.terminalOutcome.text === 'string') && typeof entry.terminalOutcome.reason === 'string'
+                && (entry.terminalOutcome.failureKind === undefined || ['authentication', 'preparation-unavailable', 'missing-binary', 'timeout', 'usage-limit', 'invalid-model', 'transient', 'unknown'].includes(String(entry.terminalOutcome.failureKind)))
+                && (entry.terminalOutcome.completedAt === undefined || typeof entry.terminalOutcome.completedAt === 'number' && Number.isFinite(entry.terminalOutcome.completedAt) && entry.terminalOutcome.completedAt > 0)
+                && (entry.terminalOutcome.harnessIdentity === undefined || typeof entry.terminalOutcome.harnessIdentity === 'string')
+                && (entry.terminalOutcome.stopped === undefined || typeof entry.terminalOutcome.stopped === 'boolean')
+                && (entry.terminalOutcome.workerIsLive === undefined || typeof entry.terminalOutcome.workerIsLive === 'boolean')
+                && (entry.terminalOutcome.replyingToClaim === undefined || entry.terminalOutcome.replyingToClaim === null || typeof entry.terminalOutcome.replyingToClaim === 'string')
+                && (entry.terminalOutcome.disposition === undefined || record(entry.terminalOutcome.disposition) && ['done', 'died'].includes(String(entry.terminalOutcome.disposition.worker)) && typeof entry.terminalOutcome.disposition.reason === 'string' && ['done', 'needs-input', 'retry', 'failed'].includes(String(entry.terminalOutcome.disposition.todo)))
+                && (entry.terminalOutcome.level === undefined || [1, 2, 3].includes(Number(entry.terminalOutcome.level)))
+                && (entry.terminalOutcome.workItemId === undefined || entry.terminalOutcome.workItemId === null || typeof entry.terminalOutcome.workItemId === 'string'))
             && (entry.preparationFailure === undefined || record(entry.preparationFailure)
                 && typeof entry.preparationFailure.reason === 'string' && [1, 2, 3].includes(Number(entry.preparationFailure.level))
                 && record(entry.reference) && entry.reference.surface === 'panel')
@@ -73,7 +86,7 @@ function readStore() {
     const store = value;
     const intents = readIntents();
     for (const entry of store.entries) {
-        if (!entry.preparationFailure)
+        if (!entry.preparationFailure && !entry.terminalOutcome)
             entry.interruption ??= intents[entry.id] ?? intents[`instance:${entry.instanceNonce}`] ?? null;
     }
     return store;
@@ -192,18 +205,19 @@ export function resumeOwnedWorkAdmission() {
 export function reserveOwnedWork(ref, harness = null, workId) {
     const owner = requireContext();
     const store = readStore();
-    const prior = store.entries.find((row) => row.unstarted && row.instanceNonce === owner.instanceNonce
+    const prior = store.entries.find((row) => row.unstarted && !row.spawning && !row.interruption && !preparing.has(row.id) && row.accountId === owner.accountId && row.machineId === owner.machineId
         && row.reference && (ref ? sameAttempt(row.reference, ref) : workId ? row.reference.surface === 'panel' && row.reference.runId === workId : false));
     const entry = prior ?? {
         id: randomUUID(), accountId: owner.accountId, machineId: owner.machineId, instanceNonce: owner.instanceNonce,
         harness, reference: ref, process: null, descendants: [], state: 'pending', interruption: null,
     };
-    entry.unstarted = false;
+    preparing.add(entry.id);
+    entry.instanceNonce = owner.instanceNonce;
     if (harness)
         entry.harness = harness;
     if (ref) {
         entry.reference = ref;
-        store.entries = store.entries.filter((row) => row.id === entry.id || !row.unstarted || !row.reference || !sameAttempt(row.reference, ref));
+        store.entries = store.entries.filter((row) => row.id === entry.id || row.accountId !== owner.accountId || row.machineId !== owner.machineId || !row.unstarted || !row.reference || !sameAttempt(row.reference, ref));
     }
     if (!prior)
         store.entries.push(entry);
@@ -241,6 +255,7 @@ export function reserveOwnedWork(ref, harness = null, workId) {
                 throw new Error('Work was interrupted before its harness could start.');
             }
             changeEntry(entry.id, (row) => {
+                row.unstarted = false;
                 row.spawning = true;
                 row.gatedCreation = true;
                 if (process.platform === 'win32')
@@ -248,11 +263,18 @@ export function reserveOwnedWork(ref, harness = null, workId) {
             });
             creating.add(entry.id);
         },
+        deferOutcome: (outcome) => {
+            changeEntry(entry.id, row => { if (!row.interruption)
+                row.terminalOutcome = outcome; });
+        },
+        acknowledgeOutcome: () => { if (readStore().entries.some(row => row.id === entry.id))
+            changeEntry(entry.id, row => { delete row.terminalOutcome; }); },
         complete: () => {
+            preparing.delete(entry.id);
             const current = readStore().entries.find((row) => row.id === entry.id);
             if (current?.preparationFailure && current.state !== 'exited')
                 throw new Error('The unprompted harness must exit before its preparation failure is released.');
-            if (current && !current.interruption)
+            if (current && !current.interruption && !current.terminalOutcome)
                 removeEntry(entry.id);
         },
         deferFailure: (reason, level) => {
@@ -268,12 +290,13 @@ export function reserveOwnedWork(ref, harness = null, workId) {
         },
         exited: () => confirmOwnedExecutionExited(entry.id),
         finishPreparation: () => {
+            preparing.delete(entry.id);
             if (registering)
                 return;
             const current = readStore().entries.find((row) => row.id === entry.id);
             if (!current)
                 return;
-            if (current.preparationFailure)
+            if (current.preparationFailure || current.terminalOutcome || current.unstarted && current.rpcId && !current.interruption)
                 return;
             if (current.interruption && current.reference)
                 changeEntry(entry.id, (row) => { row.state = 'exited'; });
@@ -288,14 +311,14 @@ export function reserveOwnedWork(ref, harness = null, workId) {
             row.reference = value;
             if (agent)
                 row.harness = agent;
-            current.entries = current.entries.filter((item) => item.id === entry.id || !item.unstarted || !item.reference || !sameAttempt(item.reference, value));
+            current.entries = current.entries.filter((item) => item.id === entry.id || item.accountId !== owner.accountId || item.machineId !== owner.machineId || !item.unstarted || !item.reference || !sameAttempt(item.reference, value));
             writeStore(current);
         },
         abandon: () => {
             const current = readStore().entries.find((candidate) => candidate.id === entry.id);
             if (!current)
                 return;
-            if (current.preparationFailure)
+            if (current.preparationFailure || current.terminalOutcome || current.unstarted && current.rpcId && !current.interruption)
                 return;
             if (current.process)
                 throw new Error('A registered process must be observed exited before its record is released.');
@@ -397,6 +420,14 @@ export async function snapshotOwnedWork(deadline) {
     const store = readStore();
     const result = { active: [], pending: [], claimPending: [], unknown: [], receipts: 0, legacyHeldTodoIds: [] };
     for (const entry of store.entries) {
+        if (entry.terminalOutcome) {
+            result.receipts++;
+            continue;
+        }
+        if (entry.unstarted && !entry.spawning && !entry.interruption && !entry.preparationFailure && !preparing.has(entry.id)) {
+            result.claimPending.push(summary(entry));
+            continue;
+        }
         if (entry.preparationFailure) {
             result.receipts++;
             if (entry.state === 'exited')
@@ -574,6 +605,29 @@ export function acknowledgeInterruption(id) {
     }
     removeEntry(id);
 }
+export function updateTerminalOutcome(id, outcome) {
+    const owner = requireContext();
+    const row = readStore().entries.find(entry => entry.id === id && entry.accountId === owner.accountId && entry.machineId === owner.machineId);
+    if (!row?.terminalOutcome)
+        throw new Error('The completed outcome no longer belongs to this account.');
+    changeEntry(id, entry => { entry.terminalOutcome = outcome; });
+}
+export function pendingTerminalOutcomes() {
+    const owner = requireContext();
+    return readStore().entries.flatMap(entry => entry.accountId === owner.accountId && entry.machineId === owner.machineId
+        && entry.reference && entry.terminalOutcome && entry.state === 'exited' && !entry.interruption
+        ? [{ id: entry.id, harness: entry.harness, reference: entry.reference, outcome: entry.terminalOutcome }] : []);
+}
+export function acknowledgeTerminalOutcome(id) {
+    const owner = requireContext();
+    const entry = readStore().entries.find(row => row.id === id);
+    if (!entry)
+        return;
+    if (entry.accountId !== owner.accountId || entry.machineId !== owner.machineId || entry.state !== 'exited' || !entry.terminalOutcome) {
+        throw new Error('Outcome acknowledgement does not match this account and ended execution.');
+    }
+    removeEntry(id);
+}
 export function failedPanelPreparations() {
     const owner = requireContext();
     return readStore().entries.flatMap((entry) => entry.accountId === owner.accountId && entry.machineId === owner.machineId
@@ -703,23 +757,23 @@ function sameAttempt(a, b) {
             && a.grantLeases.every((source) => b.grantLeases.some((other) => other.id === source.id && other.resume_taken_at === source.resume_taken_at));
     return false;
 }
-export function beginRpcClaim(surface, action) {
+export function beginRpcClaim(surface, action, args) {
     if (!ownedWorkAllowed())
         throw new Error('This machine is not accepting new work.');
     const owner = requireContext();
     const store = readStore();
     const id = randomUUID();
     liveRpcClaims.add(id);
-    (store.rpcClaims ??= []).push({ id, surface, action, accountId: owner.accountId, machineId: owner.machineId, instanceNonce: owner.instanceNonce });
+    (store.rpcClaims ??= []).push({ id, surface, action, args, accountId: owner.accountId, machineId: owner.machineId, instanceNonce: owner.instanceNonce });
     writeStore(store);
     return id;
 }
 export function pendingRpcClaims(surface) {
     const owner = requireContext();
-    return (readStore().rpcClaims ?? []).filter((row) => row.surface === surface && row.accountId === owner.accountId && row.machineId === owner.machineId && !liveRpcClaims.has(row.id));
+    return (readStore().rpcClaims ?? []).filter((row) => row.surface === surface && row.accountId === owner.accountId && row.machineId === owner.machineId && row.result === undefined && !liveRpcClaims.has(row.id));
 }
 export function deferRpcClaim(id) { liveRpcClaims.delete(id); }
-export function recordRpcClaims(id, refs, interrupted = false) {
+export function recordRpcClaims(id, refs, interrupted = false, result) {
     const owner = requireContext();
     interrupted ||= forcedOperationId !== null;
     const store = readStore();
@@ -730,27 +784,77 @@ export function recordRpcClaims(id, refs, interrupted = false) {
         return;
     }
     for (const ref of refs) {
-        if (store.entries.some((row) => row.reference && row.accountId === owner.accountId && sameAttempt(row.reference, ref)))
+        const prior = store.entries.find(row => row.reference && row.accountId === owner.accountId && sameAttempt(row.reference, ref));
+        if (prior) {
+            if (prior.unstarted && !prior.spawning && !prior.interruption)
+                prior.instanceNonce = owner.instanceNonce;
             continue;
+        }
         store.entries.push({ id: randomUUID(), accountId: owner.accountId, machineId: owner.machineId,
             instanceNonce: owner.instanceNonce, harness: null, reference: ref, process: null, descendants: [],
             state: interrupted ? 'exited' : 'pending', interruption: interrupted ? { operationId: id, interruptedAt: new Date().toISOString() } : null,
             rpcId: id, unstarted: true });
     }
-    store.rpcClaims = store.rpcClaims?.filter((row) => row.id !== id);
+    if (result && !interrupted) {
+        claim.result = result;
+        claim.instanceNonce = owner.instanceNonce;
+    }
+    else
+        store.rpcClaims = store.rpcClaims?.filter((row) => row.id !== id);
+    writeStore(store);
+    if (!result || interrupted)
+        liveRpcClaims.delete(id);
+}
+export function pendingRpcReference(ref) {
+    const owner = requireContext();
+    return readStore().entries.some(row => row.unstarted && !row.spawning && !row.interruption && !preparing.has(row.id) && row.accountId === owner.accountId && row.machineId === owner.machineId && row.reference && sameAttempt(row.reference, ref));
+}
+export function retireRpcReference(ref) {
+    const owner = requireContext(), store = readStore();
+    store.entries = store.entries.filter(row => !row.unstarted || row.spawning || row.interruption || row.accountId !== owner.accountId || row.machineId !== owner.machineId || !row.reference || !sameAttempt(row.reference, ref));
     writeStore(store);
-    liveRpcClaims.delete(id);
 }
-export function finishRpcClaims(ids) {
+export function recoveredPanelClaims() { return recoveredRpcClaims('panel'); }
+export function recoveredRpcClaims(surface) {
+    const owner = requireContext();
+    return (readStore().rpcClaims ?? []).filter(row => row.surface === surface && row.result !== undefined && row.accountId === owner.accountId && row.machineId === owner.machineId && !liveRpcClaims.has(row.id));
+}
+export function finishRpcClaims(ids, retainUnstarted = false) {
     const owner = requireContext();
     const store = readStore();
-    store.entries = store.entries.filter((row) => !row.unstarted || !row.rpcId || !ids.includes(row.rpcId)
+    for (const id of ids)
+        liveRpcClaims.delete(id);
+    if (retainUnstarted)
+        ids = ids.filter(id => !store.rpcClaims?.some(row => row.id === id && row.result === undefined) && !store.entries.some(row => row.rpcId === id && row.unstarted && !row.interruption && !row.preparationFailure && row.accountId === owner.accountId && row.machineId === owner.machineId));
+    store.rpcClaims = store.rpcClaims?.filter(row => !ids.includes(row.id) || row.accountId !== owner.accountId || row.machineId !== owner.machineId);
+    for (const id of ids)
+        liveRpcClaims.delete(id);
+    store.entries = store.entries.filter((row) => !row.unstarted || !row.rpcId || !ids.includes(row.rpcId) || preparing.has(row.id)
         || row.accountId !== owner.accountId || row.machineId !== owner.machineId || row.interruption || row.preparationFailure);
     writeStore(store);
 }
 export function pendingPanelAttempt(runId) {
     const owner = requireContext();
-    const row = readStore().entries.find((entry) => entry.instanceNonce === owner.instanceNonce && entry.state === 'pending'
+    const row = readStore().entries.find((entry) => entry.accountId === owner.accountId && entry.machineId === owner.machineId && entry.state === 'pending' && !entry.interruption && !entry.spawning
         && entry.reference?.surface === 'panel' && entry.reference.runId === runId);
     return row?.reference?.surface === 'panel' ? row.reference : null;
 }
+/** Failed cleanup stays with the account that opened the MCP session. */
+export function deferMcpCleanup(rows) {
+    if (!rows.length)
+        return;
+    const store = readStore();
+    for (const row of rows) {
+        if (!(store.mcpCleanup ??= []).some(existing => existing.accountId === row.accountId && existing.sessionId === row.sessionId))
+            store.mcpCleanup.push(row);
+    }
+    writeStore(store);
+}
+export function pendingMcpCleanup(accountId) {
+    return (readStore().mcpCleanup ?? []).filter(row => row.accountId === accountId).map(row => row.sessionId);
+}
+export function acknowledgeMcpCleanup(accountId, sessionIds) {
+    const store = readStore();
+    store.mcpCleanup = store.mcpCleanup?.filter(row => row.accountId !== accountId || !sessionIds.includes(row.sessionId));
+    writeStore(store);
+}

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.`;
+    }
+}

package/dist/index.js

@@ -6,7 +6,7 @@ import { autostartOn, autostartOff } from './autostart.js';
 import { detectAgents } from './agents.js';
 import { getMachineIdentity, clearSession, readSession, machineHostname } from './config.js';
 import { CLI_VERSION } from './package-version.js';
-import { inspectLocalRuntime, runLifecycleCommand } from './daemon-lifecycle.js';
+import { inspectLocalRuntime, runLifecycleCommand, notifySessionChanged } from './daemon-lifecycle.js';
 import { readMigration, readRuntime } from './daemon-lock.js';
 import { claudeRegisteredOnDisk, codexRegisteredOnDisk } from './mcp.js';
 import { panelCommand } from './panel3/cli.js';
@@ -110,9 +110,12 @@ async function main() {
                 throw new Error('Usage: cs ' + cmd + ' [--force]');
             return runLifecycleCommand(cmd, arg === '--force');
         case 'status': return status();
-        case 'logout':
-            console.log(clearSession() ? 'Signed out.' : 'Was not signed in.');
+        case 'logout': {
+            const signedIn = await clearSession();
+            await notifySessionChanged();
+            console.log(signedIn ? 'Signed out.' : 'Was not signed in.');
             return;
+        }
         /* THE PANEL'S OWN COMMANDS, ROUTED WHOLE. The person types one CLI, so the
            card commands are `cs` subcommands; the argument handling stays inside
            `panel3/`, which is the one import this file makes into it (named in

package/dist/login.js

@@ -2,8 +2,9 @@ import { createServer } from 'node:http';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { SUPABASE_URL, SUPABASE_KEY } from './env.js';
 import { openBrowser } from './browser.js';
-import { writeSession, getMachineIdentity } from './config.js';
-import { getClient } from './supabase.js';
+import { getMachineIdentity } from './config.js';
+import { acceptLogin } from './supabase.js';
+import { notifySessionChanged } from './daemon-lifecycle.js';
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_BODY_BYTES = 64 * 1024;
 export async function login() {
@@ -80,15 +81,12 @@ async function handleCallback(req, res, state, finish) {
         res.end(JSON.stringify({ ok: false, error: 'Invalid or missing state' }));
         return;
     }
-    writeSession({ access_token, refresh_token });
     try {
-        const client = await getClient({ refreshing: false });
-        const { data, error } = await client.auth.getUser(access_token);
-        if (error || !data.user?.email)
-            throw new Error(error?.message ?? 'No user for this session.');
+        const email = await acceptLogin({ access_token, refresh_token });
+        await notifySessionChanged();
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ ok: true }));
-        finish({ ok: true, email: data.user.email });
+        finish({ ok: true, email });
     }
     catch (err) {
         const message = `Session could not be verified: ${err.message}`;