@ctrl-spc/cs 0.7.15 → 0.7.16

package/dist/panel3/spawn.js

@@ -1,3 +1,5 @@
+import { nativeFailureKind, failureMessage } from '../failure-reason.js';
+import { CodexHomeFailure } from '../codex-home.js';
 /**
  * ═══ AGENT PANEL v3: running one headless agent and reading what it said. ═══
  *
@@ -181,6 +183,7 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
     return [
         // `-p` with the prompt on stdin. See the header.
         '-p',
+        '--output-format', 'json',
         '--mcp-config',
         JSON.stringify({ mcpServers: { [SERVER]: { type: 'http', url: toolsUrl } } }),
         '--strict-mcp-config',
@@ -297,6 +300,9 @@ function runKey(toolsUrl) {
  * present.
  */
 export function codexAnswer(stdout, exitCode = 0, stderr = '') {
+    const failureKind = nativeFailureKind(stdout, stderr);
+    if (failureKind !== 'unknown')
+        return { ok: false, failureKind, retryable: failureKind === 'transient', reason: failureMessage('codex', failureKind) };
     let text = null;
     let failure = null;
     for (const line of stdout.split('\n')) {
@@ -341,16 +347,26 @@ export function codexAnswer(stdout, exitCode = 0, stderr = '') {
     }
     return { ok: true, text: text.trim() };
 }
-/** Claude prints provider/model rejections on stdout, even with a nonzero exit. */
+/** The native result envelope distinguishes a provider failure from answer prose. */
 export function claudeAnswer(stdout, exitCode = 0, stderr = '') {
+    const failureKind = nativeFailureKind(stdout, stderr);
+    if (failureKind !== 'unknown')
+        return { ok: false, failureKind, retryable: failureKind === 'transient', reason: failureMessage('claude', failureKind) };
     if (/^\[claude-code:unrecognized_model\]/m.test(stdout + '\n' + stderr)) {
-        return { ok: false, retryable: false, reason: 'Claude rejected the selected model. Choose an available model and retry.' };
+        return { ok: false, failureKind: 'invalid-model', retryable: false, reason: 'Claude rejected the selected model. Choose an available model and retry.' };
     }
     if (exitCode !== 0)
         return { ok: false, reason: `claude exited ${exitCode}${tail(stderr) || tail(stdout)}` };
     if (stdout.trim() === '')
         return { ok: false, reason: `claude exited 0 and said nothing${tail(stderr)}` };
-    return { ok: true, text: stdout.trim() };
+    try {
+        const result = JSON.parse(stdout);
+        if (result?.type === 'result' && result.is_error === false && typeof result.result === 'string' && result.result.trim()) {
+            return { ok: true, text: result.result.trim() };
+        }
+    }
+    catch { /* A malformed native result is not a completed answer. */ }
+    return { ok: false, reason: 'Claude did not return a completed result.' };
 }
 /** Enough for any answer a person reads, and a ceiling so a runaway process
  *  cannot exhaust this daemon's memory. */
@@ -410,10 +426,10 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
         return { pid: null, session: Promise.resolve(null),
             answered: Promise.resolve({ ok: false, reason: 'Work was interrupted by the service command.' }),
             interrupted: lifecycle.interrupted, completed: lifecycle.complete };
-    const failed = (reason) => ({
+    const failed = (reason, failureKind = 'unknown') => ({
         pid: null,
         session: Promise.resolve(null),
-        answered: Promise.resolve({ ok: false, reason }),
+        answered: Promise.resolve({ ok: false, reason, failureKind, retryable: false }),
         ...(lifecycle ? { interrupted: lifecycle.interrupted, completed: lifecycle.complete } : {}),
     });
     let agent;
@@ -434,7 +450,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
     prompt = `${modelChoiceRules(agent)}\n\n${prompt}`;
     const bin = agentPath(agent);
     if (!bin) {
-        return failed(`${agent} is not installed on this machine`);
+        return failed(`${agent} is not installed on this machine`, 'missing-binary');
     }
     /* macOS uses the proven per-run home. Windows keeps its installed home so the
        Desktop runtime's ACL-bound sandbox helpers remain valid; `codexArgs`
@@ -448,10 +464,8 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
             // pass this and keep today's behaviour; see `codex-home.ts`.
             : ensureCodexRunHome({ url: toolsUrl }, null, runKey(toolsUrl), false)
         : null;
-    if (agent === 'codex' && !windowsCodex && !home) {
-        return failed('codex is not signed in on this machine, so a run cannot be given this product\'s tools '
-            + 'and nothing else. Sign codex in on the machine running this, and start it again.');
-    }
+    if (home instanceof CodexHomeFailure)
+        return failed(home.message, home.kind);
     const { args, shell } = windowsSafeSpawn(bin, ARGS);
     let child;
     try {
@@ -482,7 +496,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
         // `couldNotStart`.
         if (home && !ownerSession)
             removeCodexRunHome(home);
-        return failed(couldNotStart(err, agent));
+        return failed(couldNotStart(err, agent), 'preparation-unavailable');
     }
     let resolveSession;
     let sessionSettled = false;
@@ -575,7 +589,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
            WITHOUT the message, which is where node puts the binary's absolute path.
            The same failure as the throw above, arriving asynchronously. */
         child.on('error', (err) => {
-            finish({ ok: false, reason: couldNotStart(err, agent) });
+            finish({ ok: false, reason: couldNotStart(err, agent), failureKind: 'preparation-unavailable', retryable: false });
         });
         child.on('close', (code, signal) => {
             /* ═══ THREE OUTCOMES, AND ONLY ONE OF THEM IS AN ANSWER. ═══ A non-zero

package/dist/panel3/tools.js

@@ -1,3 +1,4 @@
+import { clientSessionCurrent } from '../supabase.js';
 import { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler, listStructureArtifactsHandler, getStructureArtifactHandler, searchAgentCardsHandler, createStructureArtifactHandler, updateStructureArtifactHandler } from '../product-tools.js';
 import { listArtifactFoldersHandler, setArtifactFolderHandler, workItemDependencyHandler } from '../product-tools.js';
 /**
@@ -3472,6 +3473,10 @@ export async function startToolsServer(client, dispatch, recoverLanding) {
         res.writeHead(status, { 'Content-Type': 'text/plain' }).end(why);
     };
     async function handle(req, res) {
+        if (!clientSessionCurrent(client)) {
+            fail(res, 401, 'This connection no longer owns the local sign-in.');
+            return;
+        }
         const url = new URL(req.url ?? '/', 'http://127.0.0.1');
         const parts = url.pathname.startsWith('/mcp/')
             ? url.pathname.slice('/mcp/'.length).split('/').filter(Boolean)

package/dist/presence-heartbeat.js

@@ -12,5 +12,8 @@ export function buildPresenceHeartbeatPayload(input, seenAt = new Date()) {
         // A beating heart is not stopped: clears the stamp a clean shutdown left,
         // so a machine that comes back reads online again.
         stopped_at: null,
+        session_state: 'authenticated',
+        session_observed_at: seenAt.toISOString(),
+        harness_auth: input.harnessAuth ?? {},
     };
 }

package/dist/presence.js

@@ -1,15 +1,15 @@
 import { platform } from 'node:os';
-import { getClient, disposeClient, confirmedSessionRejection, NotLoggedIn } from './supabase.js';
-import { getMachineIdentity, mcpToken, readSession, supersededMachineIds, clearSupersededMachineIds } from './config.js';
-import { detectAgents } from './agents.js';
+import { getClient, disposeClient, confirmedSessionRejection, NotLoggedIn, clientSessionCurrent, assertClientSession } from './supabase.js';
+import { getMachineIdentity, mcpToken, readSessionRecord, supersededMachineIds, clearSupersededMachineIds } from './config.js';
+import { detectAgents, probeHarnessAuth, harnessAuthEvidence, recordHarnessObservation } from './agents.js';
 import { installSkills } from './skills.js';
-import { startToolsServer, stopToolsServer, toolsServerStatus, registerWithClaude, registerWithCodex, unregisterFromClaude, unregisterFromCodex, agentRegStatus, heartbeatOpenSessions, setToolsClient, } from './mcp.js';
+import { startToolsServer, stopToolsServer, toolsServerStatus, registerWithClaude, registerWithCodex, unregisterFromClaude, unregisterFromCodex, agentRegStatus, heartbeatOpenSessions, reconcileMcpCleanup, } from './mcp.js';
 import { HEARTBEAT_INTERVAL_MS, COMMAND_POLL_INTERVAL_MS, ORCHESTRATOR_POLL_INTERVAL_MS } from './env.js';
 import { buildPresenceHeartbeatPayload } from './presence-heartbeat.js';
 import { createListenerState, orchestratorTick, reapDeadWorkers, recoverStrandedWorkers, reconcileInterruptedWork, refreshLegacyTodoHolds, takeRunMessages, liveAgents, } from './orchestrator.js';
 /* 18c Slice 8 — the on-disk half of the crash recovery beside it. */
 import { sweepStrandedCodexHomes } from './codex-home.js';
-import { hasOwnedWorkContext, ownedWorkAllowed, beginOwnedClaim, suspendOwnedWorkAdmission, resumeOwnedWorkAdmission, setOwnedWorkAccount, reserveOwnedWork, interruptionReceipts, acknowledgeInterruption, failedPanelPreparations, acknowledgePreparationFailure, legacyPanelSnapshotNeeded, completeLegacyPanelSnapshot, recordExitedInterruption, beginRpcClaim, deferRpcClaim, pendingRpcClaims, recordRpcClaims, finishRpcClaims, pendingPanelAttempt, ownedPanelAttemptHeld, ownedLocalPanelOwnerHeld, stopOwnedPanelAttempt } from './daemon-processes.js';
+import { hasOwnedWorkContext, pendingTerminalOutcomes, acknowledgeTerminalOutcome, ownedWorkAllowed, beginOwnedClaim, suspendOwnedWorkAdmission, resumeOwnedWorkAdmission, setOwnedWorkAccount, reserveOwnedWork, interruptionReceipts, acknowledgeInterruption, failedPanelPreparations, acknowledgePreparationFailure, legacyPanelSnapshotNeeded, completeLegacyPanelSnapshot, recordExitedInterruption, beginRpcClaim, deferRpcClaim, pendingRpcClaims, recoveredPanelClaims, recordRpcClaims, finishRpcClaims, pendingPanelAttempt, ownedPanelAttemptHeld, ownedLocalPanelOwnerHeld, stopOwnedPanelAttempt } from './daemon-processes.js';
 import { startPanel } from './panel3/run.js';
 let presence = null;
 let cloudState = 'connecting';
@@ -21,11 +21,16 @@ export async function suspendPresenceWork(options = {}) {
     await suspendOwnedWorkAdmission(options);
 }
 export function resumePresenceWork() { suspended = false; resumeOwnedWorkAdmission(); }
-function mayClaim() { return !suspended && cloudState === 'online' && ownedWorkAllowed(); }
-function panelWorkLifecycle(accountId) {
-    const allowed = () => mayClaim() && presence?.userId === accountId;
+function mayClaim() { return !!presence && clientSessionCurrent(presence.client) && !suspended && cloudState === 'online' && ownedWorkAllowed(); }
+function panelWorkLifecycle(accountId, client) {
+    const allowed = () => clientSessionCurrent(client) && mayClaim() && presence?.userId === accountId;
     return {
         allowed,
+        observeHarness: (...args) => {
+            if (clientSessionCurrent(client) && presence?.userId === accountId)
+                recordHarnessObservation(...args);
+        },
+        cloudAllowed: () => clientSessionCurrent(client) && presence?.userId === accountId,
         beginClaim: () => {
             if (!allowed())
                 throw new Error('This machine is not accepting new work.');
@@ -38,6 +43,8 @@ function panelWorkLifecycle(accountId) {
             return {
                 setAttempt: (attempt) => reservation.setReference({ surface: 'panel', ...attempt }),
                 deferFailure: reservation.deferFailure,
+                deferOutcome: reservation.deferOutcome,
+                acknowledgeOutcome: reservation.acknowledgeOutcome,
                 execution: {
                     id: reservation.id,
                     register: async (child, harness) => {
@@ -60,11 +67,14 @@ function panelWorkLifecycle(accountId) {
                 throw new Error('This execution belongs to the previous signed-in account.');
             await stopOwnedPanelAttempt(attempt);
         },
-        beginRpc: (action) => beginRpcClaim('panel', action),
+        beginRpc: (action, args) => beginRpcClaim('panel', action, args),
         deferRpc: deferRpcClaim,
         pendingRpcs: () => pendingRpcClaims('panel'),
-        recordRpc: (id, attempts, interrupted) => recordRpcClaims(id, attempts.map((attempt) => ({ surface: 'panel', ...attempt })), interrupted),
+        recoveredClaims: recoveredPanelClaims,
+        recordRpc: (id, attempts, interrupted, result) => recordRpcClaims(id, attempts.map((attempt) => ({ surface: 'panel', ...attempt })), interrupted, result),
         finishRpcs: finishRpcClaims,
+        pendingOutcomes: () => pendingTerminalOutcomes().flatMap(row => row.reference.surface === 'panel' ? [{ id: row.id, attempt: row.reference, outcome: row.outcome }] : []),
+        acknowledgeOutcome: acknowledgeTerminalOutcome,
         failedPreparations: failedPanelPreparations,
         acknowledgePreparationFailure,
         receipts: () => interruptionReceipts('panel').flatMap((receipt) => receipt.reference.surface === 'panel'
@@ -121,29 +131,7 @@ export function isPresenceRunning() {
  * whole of the daemon's life.
  */
 export function liveClient() {
-    return presence?.client ?? null;
-}
-/** Whether the heartbeat's catch block should rebuild its client from disk.
- *
- * Exact, not heuristic: a rebuild only ever helps when `session.json` holds a
- * DIFFERENT refresh token than the one the live client was built from (a
- * concurrent `cs login`, or another install on this box signing in as someone
- * else). When it holds the SAME token, `getClient` -> `setSession` -> auth-js
- * will decode it, see the exact expiry it saw last tick, and call
- * `_callRefreshToken` again against a refresh token GoTrue has already
- * revoked, repeating the same 400 `refresh_token_not_found` that ran once per
- * heartbeat tick (every 10s) instead of once per auth-js's own 60s cooldown,
- * because a brand-new client has no memory of the failure. `onDisk` null/undefined
- * (`readSession()` returns null on a missing or corrupt file, and the field is
- * optional on `StoredSession` reads) means there is nothing new to try, so it
- * also answers false rather than forcing a rebuild against nothing.
- *
- * No SupabaseClient type appears here on purpose: the decision is a pure
- * string comparison, so a test can call it with two strings and nothing else. */
-export function shouldRebuildClient(builtFrom, onDisk) {
-    if (onDisk == null)
-        return false;
-    return builtFrom !== onDisk;
+    return presence && clientSessionCurrent(presence.client) ? presence.client : null;
 }
 /** Register the one `SIGNED_OUT` handler presence relies on, and return its
  *  subscription so the caller can unsubscribe it later. Extracted so
@@ -157,12 +145,18 @@ export function shouldRebuildClient(builtFrom, onDisk) {
  *  a refresh fails non-retryably AND the access token has already expired.
  *  Nothing on disk is touched here; `cs logout` owns deleting `session.json`. */
 export function bindSignedOutWatcher(client) {
+    const generation = readSessionRecord()?.generation;
     const { data } = client.auth.onAuthStateChange((event) => {
         if (event !== 'SIGNED_OUT')
             return;
+        const record = readSessionRecord();
+        // A captured callback can arrive after unsubscribe or a replacement login.
+        if ((presence && presence.client !== client)
+            || (record?.state === 'signed-in' && record.generation !== generation))
+            return;
         console.error('Session expired and could not be refreshed. Run `cs login` to sign in again.');
         cloudState = 'sign-in-required';
-        void suspendOwnedWorkAdmission();
+        void suspendOwnedWorkAdmission({ waitForClaims: false });
         void stopToolsServer().catch((error) => console.warn(`Agent tools could not be closed: ${String(error)}`));
     });
     return data.subscription;
@@ -170,6 +164,11 @@ export function bindSignedOutWatcher(client) {
 /** A new sign-in can succeed before recovery or local tools do. Retry that
  * unfinished readiness on this same client; never rebuild a refresh writer just
  * because a recovery RPC was temporarily unavailable. */
+function observeForPresence(p) {
+    const client = p.client, accountId = p.userId;
+    return (...args) => { if (presence === p && p.userId === accountId && clientSessionCurrent(client))
+        recordHarnessObservation(...args); };
+}
 async function restorePresenceWork(p) {
     const { data, error } = await p.client.auth.getUser();
     if (error)
@@ -179,19 +178,16 @@ async function restorePresenceWork(p) {
         throw new NotLoggedIn();
     if (presence !== p)
         throw new Error('Cloud recovery was cancelled by the service command.');
-    if (currentUserId !== p.userId) {
-        console.warn('the signed-in account changed underneath this daemon — heartbeating as the account now on disk');
-        await p.panel?.stop();
-        p.userId = currentUserId;
-        p.panel = null;
-    }
+    p.userId = currentUserId;
+    assertClientSession(p.client);
     if (hasOwnedWorkContext())
         setOwnedWorkAccount(currentUserId);
-    await reconcileInterruptedWork(p.client, p.identity.id);
+    await reconcileMcpCleanup(p.client, p.userId);
+    await reconcileInterruptedWork(p.client, p.identity.id, observeForPresence(p));
     if (presence !== p)
         throw new Error('Cloud recovery was cancelled by the service command.');
     if (!p.panel)
-        p.panel = startPanel(() => p.client, hasOwnedWorkContext() ? panelWorkLifecycle(p.userId) : undefined);
+        p.panel = startPanel(p.client, hasOwnedWorkContext() ? panelWorkLifecycle(p.userId, p.client) : undefined);
     try {
         await p.panel.ready;
     }
@@ -208,6 +204,30 @@ async function restorePresenceWork(p) {
     if (!suspended)
         resumeOwnedWorkAdmission();
 }
+/** Close admission before acknowledging local replacement. Old executions retain
+ * their original client and journal; retiring the poller never kills children. */
+export async function observePresenceSession() {
+    const p = presence;
+    if (!p || clientSessionCurrent(p.client))
+        return;
+    const client = p.client;
+    // A transient storage read can recover during suspension. Remember to reopen
+    // readiness even when the same client becomes current again after the await.
+    p.readinessPending = true;
+    await suspendOwnedWorkAdmission({ waitForClaims: false });
+    if (presence !== p || p.client !== client || clientSessionCurrent(client))
+        return;
+    const record = readSessionRecord();
+    cloudState = record?.state === 'signed-in' ? 'connecting' : 'sign-in-required';
+    if (!p.retiring) {
+        p.authSubscription.unsubscribe();
+        const panel = p.panel;
+        p.panel = null;
+        p.retiring = Promise.all([panel?.stop(), disposeClient(p.client)]).then(() => { });
+        void p.retiring.catch(() => { });
+    }
+    await stopToolsServer();
+}
 async function heartbeat(p) {
     if (p.heartbeating)
         return;
@@ -220,103 +240,39 @@ async function heartbeat(p) {
     }
 }
 async function heartbeatInner(p) {
-    if (cloudState === 'sign-in-required' && !shouldRebuildClient(p.builtFromRefreshToken, readSession()?.refresh_token))
-        return;
     try {
+        await observePresenceSession();
+        const record = readSessionRecord();
+        if (record?.state !== 'signed-in')
+            return;
+        if (p.sessionGeneration !== record.generation || !clientSessionCurrent(p.client)) {
+            await p.retiring;
+            const rebuilt = await getClient();
+            if (presence !== p) {
+                await disposeClient(rebuilt);
+                return;
+            }
+            p.client = rebuilt;
+            p.sessionGeneration = record.generation;
+            p.authSubscription = bindSignedOutWatcher(rebuilt);
+            p.retiring = undefined;
+            p.readinessPending = true;
+        }
         if (p.readinessPending)
             await restorePresenceWork(p);
-        const { error } = await p.client
-            .from('cliv2_agents')
-            .upsert(buildPresenceHeartbeatPayload({
-            userId: p.userId,
-            machineId: p.identity.id,
-            machineName: p.identity.name,
-            agents: p.agents,
-            platform: p.platform,
-        }), { onConflict: 'user_id,machine_id' });
+        p.agents = detectAgents();
+        await Promise.all(p.agents.map(agent => probeHarnessAuth(agent)));
+        const { error } = await p.client.from('cliv2_agents').upsert(buildPresenceHeartbeatPayload({ userId: p.userId, machineId: p.identity.id,
+            machineName: p.identity.name, agents: p.agents, platform: p.platform, harnessAuth: harnessAuthEvidence() }), { onConflict: 'user_id,machine_id' });
         if (error)
             throw error;
         cloudState = 'online';
     }
-    catch (err) {
-        cloudState = confirmedSessionRejection(err) ? 'sign-in-required' : 'offline';
-        // A failure here used to rebuild the client from disk unconditionally, and
-        // that was the production incident: `getClient` -> `setSession` decodes
-        // whatever refresh token is on disk and hands it to auth-js, which refreshes
-        // it UNCONDITIONALLY if the access token has expired. When the disk token is
-        // the same dead one this client was already built from, that is a guaranteed
-        // repeat of the exact 400 `refresh_token_not_found` that got us here, once
-        // per 10s heartbeat tick instead of once per auth-js's own 60s cooldown (that
-        // cooldown lives on the client instance, and a fresh client every tick never
-        // accumulates it). 7,028 refresh requests in one window, read off this
-        // machine's own logs. `shouldRebuildClient` below is the guard: only rebuild
-        // when `session.json` disagrees with the token this client holds.
-        console.warn(`heartbeat failed, will retry: ${err.message}`);
-        try {
-            const onDisk = readSession()?.refresh_token;
-            if (shouldRebuildClient(p.builtFromRefreshToken, onDisk)) {
-                // KEEPING THE REBUILD, NOT DELETING IT: every client here is built with
-                // `persistSession: false`, which selects auth-js's in-memory storage
-                // adapter, so `getUser()` reads that client's own memory and never reads
-                // `session.json`. `getClient()` -> `readSession()` -> `setSession()` is the
-                // ONLY path in this process from disk to a live client. Deleting the
-                // rebuild (proposed twice already in earlier drafts of this fix) would make
-                // the account-reconciliation below unreachable and a concurrent `cs login`
-                // unrecoverable without restarting the daemon.
-                await suspendOwnedWorkAdmission();
-                p.readinessPending = true;
-                p.authSubscription.unsubscribe();
-                // Tool transports close over their startup client/account. Replacing
-                // only the session heartbeat client would leave new work on old auth.
-                await stopToolsServer();
-                await disposeClient(p.client);
-                const rebuilt = await getClient();
-                p.authSubscription = bindSignedOutWatcher(rebuilt);
-                p.client = rebuilt;
-                // shouldRebuildClient already ruled out onDisk being null/undefined to
-                // reach this branch; the `as string` reflects that guarantee rather
-                // than reintroducing a null fallback that can't occur.
-                p.builtFromRefreshToken = onDisk;
-                // FIX 2: flow the rebuilt client (fresh/refreshed token) into the tools
-                // session-lifecycle heartbeat too, so a wedged token can't leave the session
-                // heartbeat 401ing forever (the CLI-v1 stale-token root cause). No-op unless
-                // the tools server is running.
-                setToolsClient(p.client);
-                /* ═══ !Cleanup PHASE 0 (I1) — RE-RESOLVE WHO WE ARE, NOT JUST THE TOKEN.
-                   THE WEDGE THIS FIXES, read off this machine's own 6.1 MB log: an
-                   unbroken wall of
-        
-                     heartbeat failed, will retry: new row violates row-level security
-                     policy for table "cliv2_agents"
-        
-                   and presence stayed dead until the daemon was killed by hand.
-        
-                   `p.userId` is resolved ONCE, at startPresence, and the payload sends it
-                   EXPLICITLY while the table's policy is `with check (auth.uid() =
-                   user_id)`. The recovery above rebuilt the CLIENT from disk but left
-                   `p.userId` alone — so the moment `session.json` came to hold a different
-                   account (a second install on this box signing in; a demo lane; a
-                   re-login as someone else), every heartbeat sent one user's id under
-                   another user's token and the database correctly refused it. Rebuilding
-                   the client changed nothing, because the disk session was not the stale
-                   half. It could never recover on its own: the retry re-sent the same
-                   disagreement, several times a minute, forever.
-        
-                   Evidence it really happened here rather than in theory: `cliv2_agents`
-                   holds TWO rows for this machine_id under two different user_ids, one of
-                   them stuck at the epoch.
-        
-                   THE TOKEN IS THE AUTHORITY. `auth.uid()` is what the database will
-                   believe whatever this process thinks, so the id is taken FROM the
-                   rebuilt client rather than held against it. Warned rather than silent:
-                   a daemon that starts heartbeating as a different user has had the
-                   machine change owner underneath it, and that is worth a line. */
-                await restorePresenceWork(p);
-            }
-        }
-        catch (error) {
-            cloudState = error instanceof NotLoggedIn || confirmedSessionRejection(error) ? 'sign-in-required' : 'offline';
-        }
+    catch (error) {
+        cloudState = error instanceof NotLoggedIn || confirmedSessionRejection(error) ? 'sign-in-required' : 'offline';
+        await suspendOwnedWorkAdmission({ waitForClaims: false });
+        p.readinessPending = true;
+        console.warn(`Cloud readiness could not be restored: ${error.message}`);
     }
     // Re-attempt agent registration each heartbeat for any detected agent still
     // idle or failed, while the tools server is up. Registration otherwise fires
@@ -380,8 +336,10 @@ async function pollCommands(p) {
     if (p.pollingCommands)
         return;
     p.pollingCommands = true;
+    const client = p.client;
+    const panel = p.panel;
     try {
-        const { data, error } = await p.client
+        const { data, error } = await client
             .from('cliv2_commands')
             .update({ status: 'ack', acked_at: new Date().toISOString() })
             .eq('machine_id', p.identity.id)
@@ -392,7 +350,7 @@ async function pollCommands(p) {
             throw error;
         for (const cmd of data ?? [])
             console.log(`Acked ${cmd.command} (${cmd.id})`);
-        const { data: restarts, error: restartError } = await p.client
+        const { data: restarts, error: restartError } = await client
             .from('cliv2_commands')
             .update({ status: 'processing' })
             .eq('machine_id', p.identity.id)
@@ -408,15 +366,16 @@ async function pollCommands(p) {
                 if (Date.now() - Date.parse(command.created_at) > 30_000) {
                     throw new Error('This restart request expired. Try again while the machine is online.');
                 }
-                if (!p.panel)
+                assertClientSession(client);
+                if (!panel)
                     throw new Error('The worker has not started. Open Companion on this machine and reconnect.');
-                await p.panel.restart();
+                await panel.restart();
             }
             catch (error) {
                 status = 'failed';
                 result = error instanceof Error ? error.message : String(error);
             }
-            const { error: saved } = await p.client.from('cliv2_commands')
+            const { error: saved } = await client.from('cliv2_commands')
                 .update({ status, result, acked_at: new Date().toISOString() }).eq('id', command.id);
             if (saved)
                 throw saved;
@@ -445,6 +404,7 @@ async function pollCommands(p) {
 async function pollOrchestrator(p) {
     if (!mayClaim())
         return;
+    const client = p.client, accountId = p.userId;
     /* !Cleanup Phase 0 (I5c) — WHICH CTRL+SPC SERVER THE WORKER MAY REACH.
        Read here, per tick, for the same reason `liveAgents()` is: the tools server
        can come up after the first tick, and a snapshot taken at `startPresence`
@@ -454,6 +414,10 @@ async function pollOrchestrator(p) {
        pointed at a different account was found registered and listening. */
     const server = toolsServerStatus();
     await orchestratorTick({
+        observeHarness: (...args) => {
+            if (clientSessionCurrent(client) && presence?.userId === accountId)
+                recordHarnessObservation(...args);
+        },
         client: p.client,
         userId: p.userId,
         machineId: p.identity.id,
@@ -470,6 +434,7 @@ export async function startPresence() {
     if (stopping)
         await stopping;
     if (presence) {
+        await heartbeat(presence);
         return { machineName: presence.identity.name, agents: presence.agents };
     }
     if (starting)
@@ -533,7 +498,7 @@ export async function startPresence() {
             cp: setInterval(() => { }, COMMAND_POLL_INTERVAL_MS),
             ot: setInterval(() => { }, ORCHESTRATOR_POLL_INTERVAL_MS),
             listener: createListenerState(),
-            builtFromRefreshToken: readSession()?.refresh_token ?? null,
+            sessionGeneration: readSessionRecord().generation,
             authSubscription,
         };
         clearInterval(p.hb);
@@ -548,11 +513,12 @@ export async function startPresence() {
            self-heals, and the worker's unique index would refuse the retry. Scoped
            to this machine's own id: if this daemon is starting, nothing it started
            is still running. */
-        await reconcileInterruptedWork(p.client, identity.id);
+        await reconcileMcpCleanup(p.client, p.userId);
+        await reconcileInterruptedWork(p.client, identity.id, observeForPresence(p));
         if (presence !== p)
             throw new Error('Cloud startup was cancelled by the service command.');
         if (!p.panel)
-            p.panel = startPanel(() => p.client, hasOwnedWorkContext() ? panelWorkLifecycle(p.userId) : undefined);
+            p.panel = startPanel(p.client, hasOwnedWorkContext() ? panelWorkLifecycle(p.userId, p.client) : undefined);
         await p.panel.ready;
         if (presence !== p)
             throw new Error('Cloud startup was cancelled by the service command.');
@@ -619,10 +585,14 @@ export async function startPresence() {
                    than starting an agent that could read none of the work. */
                 if (!mayClaim())
                     return;
-                await reconcileInterruptedWork(p.client, p.identity.id);
+                await reconcileMcpCleanup(p.client, p.userId);
+                await reconcileInterruptedWork(p.client, p.identity.id, observeForPresence(p));
                 await refreshLegacyTodoHolds(p.client, p.identity.id);
                 const server = toolsServerStatus();
-                void takeRunMessages(p.client, p.userId, p.identity.id, liveAgents(), p.listener, console.log, console.warn, server.running ? { port: server.port, token: mcpToken() } : null);
+                void takeRunMessages(p.client, p.userId, p.identity.id, liveAgents(), p.listener, console.log, console.warn, server.running ? { port: server.port, token: mcpToken() } : null, undefined, undefined, (...args) => {
+                    if (clientSessionCurrent(p.client) && presence?.userId === p.userId)
+                        recordHarnessObservation(...args);
+                });
             })().catch((error) => { cloudState = confirmedSessionRejection(error) ? 'sign-in-required' : 'offline'; console.warn(`Cloud work is paused: ${String(error)}`); });
             /* !Cleanup Phase 6b (I43) — THE LIVENESS WATCH, on the heartbeat rather
                than the orchestrator tick.
@@ -669,7 +639,6 @@ export async function startPresence() {
                stale-token root cause, reintroduced by ordering alone.
                `p.client` rather than `client`, because the whole point is to pick up a
                rebuild the local const cannot see. */
-            setToolsClient(p.client);
             /* The instructions belong to the release, so they are rewritten beside
                registration on every start: the pair is "make this machine's agents
                ready", and a machine registered against current tools while reading a
@@ -687,6 +656,14 @@ export async function startPresence() {
         }
         // Both cs open and cs start answer cards through this one lifecycle.
         // Read the owner's client on every use, including after refresh or logout.
+        if (presence !== p)
+            throw new Error('Cloud startup was cancelled by the service command.');
+        assertClientSession(p.client);
+        // A failed earlier startup may have closed admission before retiring its
+        // presence. A healthy replacement must reopen it, unless recovery or an
+        // explicit service stop still owns that decision.
+        if (!p.readinessPending && !suspended)
+            resumeOwnedWorkAdmission();
         return { machineName: identity.name, agents };
     })();
     try {
@@ -747,7 +724,6 @@ export async function stopPresence({ unregister = false } = {}) {
            session, one that is signed in and healthy. */
         p.authSubscription.unsubscribe();
         await p.panel?.stop();
-        await disposeClient(p.client);
         // On logout (unregister), scrub the ctrl-spc entry from each detected agent's
         // config so a logged-out machine leaves no dead server that would read "failed
         // to connect" on the next agent run. Fire-and-forget best-effort — never blocks
@@ -767,7 +743,8 @@ export async function stopPresence({ unregister = false } = {}) {
                 .update({ stopped_at: new Date().toISOString() })
                 .eq('machine_id', p.identity.id);
         }
-        catch { /* ignore — a lapsed heartbeat reads as offline anyway */ }
+        catch { /* A lapsed heartbeat reads as offline. */ }
+        await disposeClient(p.client);
     })();
     try {
         await stopping;