@ctrl-spc/cs 0.7.14 → 0.7.16

package/dist/presence.js

@@ -1,17 +1,91 @@
 import { platform } from 'node:os';
-import { getClient } 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, takeRunMessages, liveAgents, } from './orchestrator.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 { claimDaemonLock, releaseDaemonLock } from './daemon-lock.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';
+let suspended = false;
+let presenceGeneration = 0;
+export function presenceCloudState() { return cloudState; }
+export async function suspendPresenceWork(options = {}) {
+    suspended = true;
+    await suspendOwnedWorkAdmission(options);
+}
+export function resumePresenceWork() { suspended = false; resumeOwnedWorkAdmission(); }
+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.');
+            return beginOwnedClaim();
+        },
+        prepare: (runId) => {
+            if (presence?.userId !== accountId)
+                throw new Error('This execution belongs to the previous signed-in account.');
+            const reservation = reserveOwnedWork(null, null, runId);
+            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) => {
+                        await reservation.register(child, harness);
+                    },
+                    interrupted: reservation.interrupted,
+                    exited: reservation.exited,
+                    complete: reservation.complete,
+                    beforeSpawn: reservation.beforeSpawn,
+                    waitForPromptAdmission: reservation.waitForPromptAdmission,
+                },
+                finish: reservation.finishPreparation,
+            };
+        },
+        claimAttempt: pendingPanelAttempt,
+        heldLocalOwner: ownedLocalPanelOwnerHeld,
+        heldAttempt: (attempt) => presence?.userId !== accountId || ownedPanelAttemptHeld(attempt),
+        stopHeldAttempt: async (attempt) => {
+            if (presence?.userId !== accountId)
+                throw new Error('This execution belongs to the previous signed-in account.');
+            await stopOwnedPanelAttempt(attempt);
+        },
+        beginRpc: (action, args) => beginRpcClaim('panel', action, args),
+        deferRpc: deferRpcClaim,
+        pendingRpcs: () => pendingRpcClaims('panel'),
+        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'
+            ? [{ id: receipt.id, operationId: receipt.operationId, interruptedAt: receipt.interruptedAt,
+                    pid: receipt.process?.pid ?? null, attempt: receipt.reference }] : []),
+        acknowledge: acknowledgeInterruption,
+        legacyRequired: legacyPanelSnapshotNeeded,
+        recordLegacy: (attempt) => recordExitedInterruption({ surface: 'panel', ...attempt }),
+        legacyComplete: completeLegacyPanelSnapshot,
+    };
+}
 /** In-flight guard: startPresence yields to the event loop (network setSession)
  *  before `presence` is assigned, so a plain `if (presence)` check lets two
  *  concurrent callers both build interval pairs — the first pair then leaks and
@@ -57,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
@@ -93,103 +145,134 @@ 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.');
-        void stopPresence();
+        cloudState = 'sign-in-required';
+        void suspendOwnedWorkAdmission({ waitForClaims: false });
+        void stopToolsServer().catch((error) => console.warn(`Agent tools could not be closed: ${String(error)}`));
     });
     return data.subscription;
 }
+/** 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)
+        throw error;
+    const currentUserId = data.user?.id;
+    if (!currentUserId)
+        throw new NotLoggedIn();
+    if (presence !== p)
+        throw new Error('Cloud recovery was cancelled by the service command.');
+    p.userId = currentUserId;
+    assertClientSession(p.client);
+    if (hasOwnedWorkContext())
+        setOwnedWorkAccount(currentUserId);
+    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, p.client) : undefined);
+    try {
+        await p.panel.ready;
+    }
+    catch (error) {
+        await p.panel.stop();
+        p.panel = null;
+        throw error;
+    }
+    await startToolsServer({ client: p.client, userId: p.userId, machineId: p.identity.id });
+    if (presence !== p)
+        throw new Error('Cloud recovery was cancelled by the service command.');
+    p.readinessPending = false;
+    cloudState = 'online';
+    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;
+    p.heartbeating = true;
     try {
-        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' });
-        if (error)
-            throw error;
+        await heartbeatInner(p);
     }
-    catch (err) {
-        // 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.
-                const rebuilt = await getClient();
-                p.authSubscription.unsubscribe();
-                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. */
-                const { data } = await p.client.auth.getUser();
-                const currentUserId = data.user?.id;
-                if (currentUserId && currentUserId !== p.userId) {
-                    console.warn('the signed-in account changed underneath this daemon — heartbeating as the account now on disk');
-                    p.userId = currentUserId;
-                }
+    finally {
+        p.heartbeating = false;
+    }
+}
+async function heartbeatInner(p) {
+    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;
         }
-        catch { /* stay down until the next tick */ }
+        if (p.readinessPending)
+            await restorePresenceWork(p);
+        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 (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
@@ -248,11 +331,15 @@ async function cleanupSupersededRows(p) {
     }
 }
 async function pollCommands(p) {
+    if (cloudState !== 'online')
+        return;
     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)
@@ -263,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)
@@ -279,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;
@@ -314,6 +402,9 @@ async function pollCommands(p) {
  * daemon. Same reasoning as the heartbeat's per-tick `detectAgents()`.
  */
 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`
@@ -323,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,
@@ -339,17 +434,21 @@ export async function startPresence() {
     if (stopping)
         await stopping;
     if (presence) {
+        await heartbeat(presence);
         return { machineName: presence.identity.name, agents: presence.agents };
     }
     if (starting)
         return starting;
+    const generation = presenceGeneration;
     starting = (async () => {
-        const lock = claimDaemonLock();
-        if (lock.held)
-            throw new Error(`CTRL+SPC is already running on this computer (pid ${lock.pid}).`);
+        cloudState = 'connecting';
         const identity = getMachineIdentity();
         const agents = detectAgents();
         const client = await getClient();
+        if (generation !== presenceGeneration) {
+            await disposeClient(client);
+            throw new Error('Cloud startup was cancelled by the service command.');
+        }
         /* ═══ A DEAD SESSION STOPS THE LOOPS. IT DOES NOT SLOW THEM DOWN. ═══
            The refresh token can die while the daemon runs (a re-login elsewhere
            rotates it out from under this process), and until this existed nothing
@@ -374,10 +473,20 @@ export async function startPresence() {
            binding and the heartbeat's post-rebuild rebind are the same code and
            can never drift out of sync with each other. */
         const authSubscription = bindSignedOutWatcher(client);
-        const { data } = await client.auth.getUser();
+        const { data, error: identityError } = await client.auth.getUser();
         const userId = data.user?.id;
-        if (!userId)
-            throw new Error('Signed-in user could not be resolved. Sign in again.');
+        if (identityError || !userId) {
+            authSubscription.unsubscribe();
+            await disposeClient(client);
+            throw identityError ?? new NotLoggedIn();
+        }
+        if (generation !== presenceGeneration) {
+            authSubscription.unsubscribe();
+            await disposeClient(client);
+            throw new Error('Cloud startup was cancelled by the service command.');
+        }
+        if (hasOwnedWorkContext())
+            setOwnedWorkAccount(userId);
         const p = {
             client,
             panel: null,
@@ -389,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);
@@ -404,6 +513,15 @@ 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 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, p.client) : undefined);
+        await p.panel.ready;
+        if (presence !== p)
+            throw new Error('Cloud startup was cancelled by the service command.');
         await recoverStrandedWorkers(p.client, identity.id);
         /* 18c SLICE 8 — AND RECLAIM WHAT A PREVIOUS LIFE LEFT ON DISK. A codex worker
            runs against a per-run `$CODEX_HOME` seeded with a COPY OF THE USER'S
@@ -429,6 +547,8 @@ export async function startPresence() {
            argument, including why an age-based scope was measured and rejected, is
            in `sweepStrandedCodexHomes`. Do not re-widen this to the root. */
         sweepStrandedCodexHomes();
+        if (presence !== p)
+            throw new Error('Cloud startup was cancelled by the service command.');
         p.hb = setInterval(() => {
             /* ═══ 18k SLICE 7 — TAKE THE MESSAGES, AWAITED AFTER THE HEARTBEAT. ═══
       
@@ -463,9 +583,17 @@ export async function startPresence() {
                    leave every answer for the rest of the session with no tools. Null
                    while it is down, and `takeRunMessages` then answers nothing rather
                    than starting an agent that could read none of the work. */
+                if (!mayClaim())
+                    return;
+                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.
       
@@ -477,7 +605,8 @@ export async function startPresence() {
                Scoped to this machine's own workers and gated on BOTH a stale
                `updated_at` and a genuinely dead process, so an agent inside a long
                tool call is never reaped for being quiet. */
-            void reapDeadWorkers(p.client, p.identity.id, p.listener.livePids);
+            if (mayClaim())
+                void reapDeadWorkers(p.client, p.identity.id, p.listener.livePids);
         }, HEARTBEAT_INTERVAL_MS);
         p.cp = setInterval(() => void pollCommands(p), COMMAND_POLL_INTERVAL_MS);
         p.ot = setInterval(() => void pollOrchestrator(p), ORCHESTRATOR_POLL_INTERVAL_MS);
@@ -495,7 +624,7 @@ export async function startPresence() {
         // best-effort: a tools-server or registration failure must never break the
         // presence heartbeat above, so it's caught and warned like everything here.
         try {
-            await startToolsServer({ client, userId, machineId: identity.id });
+            await startToolsServer({ client: p.client, userId: p.userId, machineId: identity.id });
             /* ═══ AND THE TOOLS SERVER IS POINTED AT WHATEVER CLIENT IS LIVE BY NOW,
                WHICH IS NOT NECESSARILY THE ONE IT WAS JUST STARTED WITH. ═══
                `startToolsServer` sets `toolsClient = deps.client`, and `deps.client`
@@ -510,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
@@ -528,7 +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.
-        p.panel = startPanel(() => p.client);
+        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 {
@@ -536,7 +671,7 @@ export async function startPresence() {
     }
     catch (error) {
         await stopPresence();
-        releaseDaemonLock();
+        cloudState = error instanceof NotLoggedIn || confirmedSessionRejection(error) ? 'sign-in-required' : 'offline';
         throw error;
     }
     finally {
@@ -561,6 +696,7 @@ export async function startPresence() {
 export async function stopPresence({ unregister = false } = {}) {
     if (stopping)
         return stopping;
+    presenceGeneration++;
     const p = presence;
     if (!p)
         return;
@@ -607,13 +743,13 @@ 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;
     }
     finally {
         stopping = null;
-        releaseDaemonLock();
     }
 }