@ctrl-spc/cs 0.7.13 → 0.7.15

package/dist/panel3/spawn.js

@@ -123,7 +123,7 @@ import { spawn as spawnChild } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { agentPath } from '../agents.js';
 import { ensureCodexRunHome, ensurePanel3CodexOwnerHome, removeCodexRunHome, } from '../codex-home.js';
-import { windowsSafeSpawn } from '../win-shell.js';
+import { windowsSafeSpawn, spawnOwnedProcess, releaseOwnedProcess } from '../win-shell.js';
 import { modelChoiceRules } from './prompt.js';
 const AGENT_VAR = 'CTRL_SPC_V3_AGENT';
 /**
@@ -405,11 +405,16 @@ function tail(text, chars = 500) {
  * process still alive" after the daemon that started it has been killed. So the
  * caller gets the pid immediately, writes it, and then waits.
  */
-export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings = {}) {
+export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings = {}, lifecycle) {
+    if (lifecycle?.interrupted())
+        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) => ({
         pid: null,
         session: Promise.resolve(null),
         answered: Promise.resolve({ ok: false, reason }),
+        ...(lifecycle ? { interrupted: lifecycle.interrupted, completed: lifecycle.complete } : {}),
     });
     let agent;
     try {
@@ -450,10 +455,12 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
     const { args, shell } = windowsSafeSpawn(bin, ARGS);
     let child;
     try {
-        child = spawnChild(bin, args, {
+        lifecycle?.beforeSpawn();
+        const options = {
             // The repo-wide invariant for ANY child process (MEMORY: "Windows silence
             // decision"). A user must never see a console flash.
             windowsHide: true,
+            detached: process.platform !== 'win32',
             shell,
             stdio: ['pipe', 'pipe', 'pipe'],
             // NEVER the daemon's inherited cwd, which under a launchd login item is
@@ -465,7 +472,10 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
                said. Claude is spawned with the environment untouched, exactly as
                before. */
             ...(home ? { env: { ...process.env, CODEX_HOME: home } } : {}),
-        });
+        };
+        child = lifecycle
+            ? spawnOwnedProcess(bin, args, options, lifecycle.id)
+            : spawnChild(bin, args, options);
     }
     catch (err) {
         // NOT `err.message`, which names the binary's absolute path. See
@@ -488,6 +498,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
     else if (agent === 'claude') {
         observeSession(launchedOwnerSession?.resumeSessionId ?? launchedOwnerSession?.freshSessionId ?? null);
     }
+    let registration = Promise.resolve();
     const answered = new Promise((resolve) => {
         let stdout = '';
         let stderr = '';
@@ -512,11 +523,32 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
             /* THE CREDENTIAL COPY GOES WHEN THE RUN DOES. `codex-home.ts` calls this
                the primary reclaim and the startup sweep the backstop; a home left
                behind holds a copy of the user's codex credential. */
-            if (home && !ownerSession)
-                removeCodexRunHome(home);
-            if (!sessionSettled)
-                observeSession(null);
-            resolve(answer);
+            void (async () => {
+                await registration.catch(() => { });
+                if (lifecycle && child.pid) {
+                    // A wrapper's close is not tree exit. Keep the run owned until the
+                    // actual descendants end; lifecycle commands have their own deadline.
+                    let warned = false;
+                    while (true) {
+                        try {
+                            await lifecycle.exited();
+                            break;
+                        }
+                        catch (error) {
+                            if (!warned) {
+                                console.warn(`Owned agent execution has not ended: ${error.message}`);
+                                warned = true;
+                            }
+                            await new Promise((done) => setTimeout(done, 250));
+                        }
+                    }
+                }
+                if (home && !ownerSession)
+                    removeCodexRunHome(home);
+                if (!sessionSettled)
+                    observeSession(null);
+                resolve(answer);
+            })();
         };
         child.stdout?.on('data', (d) => {
             stdout = collect(stdout, String(d));
@@ -582,7 +614,23 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
            handler the EPIPE is an unhandled stream error and takes the daemon down
            with it. */
         child.stdin?.on('error', () => { });
-        child.stdin?.end(prompt);
+        if (lifecycle) {
+            registration = lifecycle.register(child, agent);
+            void registration.then(() => {
+                if (lifecycle.interrupted())
+                    return;
+                releaseOwnedProcess(child);
+                child.stdin?.end(prompt);
+            }).catch((error) => {
+                // No prompt was delivered. The held native handle may be cancelled
+                // even when durable ownership registration itself failed.
+                child.stdin?.destroy();
+                child.kill('SIGKILL');
+                finish({ ok: false, reason: `The agent could not be safely registered: ${error.message}` });
+            });
+        }
+        else
+            child.stdin?.end(prompt);
     });
-    return { pid: child.pid ?? null, session, answered };
+    return { pid: child.pid ?? null, session, answered, ...(lifecycle ? { interrupted: lifecycle.interrupted, completed: lifecycle.complete } : {}) };
 }

package/dist/panel3/tools.js

@@ -126,7 +126,7 @@ import { z } from 'zod';
 import { returned } from './client.js';
 import { readableWriteError, FIREWALL_WRITING_RULE } from '../firewall.js';
 import { rememberSecret, redactArgs } from './secrets.js';
-import { workBrief } from './prompt.js';
+import { workBrief, landingOutcomeContext } from './prompt.js';
 import { listCodexModels } from './codex-models.js';
 /* The harness this daemon spawns with, which is the process this server runs
    in. It is what `panel3_runs.harness` is written from at spawn, so reading it
@@ -2030,6 +2030,26 @@ const TOOLS = [
                 + 'Nobody will be asked again.';
         },
     },
+    {
+        name: 'recover_landing',
+        levels: [2],
+        description: 'Recover a merge the person already approved. The product manages Git metadata; you resolve '
+            + 'and verify ordinary files in this card’s working copy. Use prepare to bring the current base '
+            + 'into the card branch, including after a restart or a Git permission failure. Resolve conflicts '
+            + 'and run checks, record write_report(work_complete=true), then use finish to retry landing. '
+            + 'No new approval is needed. Never change the sandbox or ask the person to reopen with Git access. '
+            + 'After landing succeeds, record completion again and reply. If recovery fails, report the exact remaining action.',
+        input: { action: z.enum(['prepare', 'finish']) },
+        handler: async (caller, args) => {
+            if (!caller.isOwner || caller.level !== 2 || !caller.processToken) {
+                throw new Error('Only the current conversation owner can recover its approved merge.');
+            }
+            if (!caller.recoverLanding)
+                throw new Error('Merge recovery is unavailable on this companion. Update and restart the companion on this card’s machine, then retry in this card.');
+            const { action } = args;
+            return landingOutcomeContext(await caller.recoverLanding(caller.runId, caller.processToken, action)).join('\n');
+        },
+    },
     /**
      * ═══ THE AGENT ASKS FOR THE OFFER; THE PRODUCT WRITES IT. ═══
      *
@@ -2051,7 +2071,8 @@ const TOOLS = [
         levels: [2],
         description: 'Offer the person the ending for this card: put the finished work onto the main branch, or '
             + 'leave it on its branch. Call this when the card\'s work is DONE and the codebase lands on '
-            + 'the main branch. First record verified completion with write_report(work_complete=true). '
+            + 'the main branch. If the person already approved a merge that needs recovery, use recover_landing instead of asking again. '
+            + 'First record verified completion with write_report(work_complete=true). '
             + 'Use say for progress; this tool cannot announce work you intend to do. You do not write the question or the answers and you never merge anything: '
             + 'the product composes both, and it performs the merge itself if they choose to put the work '
             + 'back. Say in one sentence what was done, in their words. After this call, stop immediately: '
@@ -2824,7 +2845,7 @@ const TOOLS = [
                 await whileRunning(client.rpc('panel3_request_completion', {
                     p_run_id: runId, p_process_token: processToken, p_summary: report,
                 }), runId, 'declare completion of');
-                return 'Completion recorded. If the finished work needs an ending choice, call offer_ending; otherwise give your final answer and exit. Done waits until all processes have exited.';
+                return 'Completion recorded. If an already-approved merge is awaiting recovery, call recover_landing(action="finish"); if the finished work needs its first ending choice, call offer_ending; otherwise give your final answer and exit. Done waits until all processes have exited.';
             }
             await whileRunning(processToken === undefined
                 ? client.from('panel3_runs').update({ report }).eq('id', runId)
@@ -3341,6 +3362,8 @@ export function toolShape(name) {
 function toolAvailable(tool, level, isOwner) {
     if (isOwner && tool.name === 'escalate')
         return false;
+    if (tool.name === 'recover_landing' && !isOwner)
+        return false;
     return tool.levels.includes(level) || (level === 2 && isOwner && workflowToolForName(tool.name) !== undefined);
 }
 function toolNamed(name) {
@@ -3431,7 +3454,7 @@ export async function processActivationIsCurrent(client, runId, processToken) {
  * below goes through the signed-in user's own token, so guessing a run id would
  * still only ever reach that user's own record.
  */
-export async function startToolsServer(client, dispatch) {
+export async function startToolsServer(client, dispatch, recoverLanding) {
     const { data, error } = await client.auth.getUser();
     if (error)
         throw new Error(`could not start the tools server: ${error.message}`);
@@ -3550,7 +3573,7 @@ export async function startToolsServer(client, dispatch) {
         };
         const server = buildServer({
             client, userId, runId, cardId: run.card_id, level: run.level,
-            processToken, isOwner, dispatch,
+            processToken, isOwner, dispatch, recoverLanding,
         });
         await server.connect(transport);
         await transport.handleRequest(req, res, body);

package/dist/presence.js

@@ -1,17 +1,81 @@
 import { platform } from 'node:os';
-import { getClient } from './supabase.js';
+import { getClient, disposeClient, confirmedSessionRejection, NotLoggedIn } from './supabase.js';
 import { getMachineIdentity, mcpToken, readSession, supersededMachineIds, clearSupersededMachineIds } from './config.js';
 import { detectAgents } from './agents.js';
 import { installSkills } from './skills.js';
 import { startToolsServer, stopToolsServer, toolsServerStatus, registerWithClaude, registerWithCodex, unregisterFromClaude, unregisterFromCodex, agentRegStatus, heartbeatOpenSessions, setToolsClient, } 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, 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 { 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 !suspended && cloudState === 'online' && ownedWorkAllowed(); }
+function panelWorkLifecycle(accountId) {
+    const allowed = () => mayClaim() && presence?.userId === accountId;
+    return {
+        allowed,
+        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,
+                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) => beginRpcClaim('panel', action),
+        deferRpc: deferRpcClaim,
+        pendingRpcs: () => pendingRpcClaims('panel'),
+        recordRpc: (id, attempts, interrupted) => recordRpcClaims(id, attempts.map((attempt) => ({ surface: 'panel', ...attempt })), interrupted),
+        finishRpcs: finishRpcClaims,
+        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
@@ -97,12 +161,70 @@ export function bindSignedOutWatcher(client) {
         if (event !== 'SIGNED_OUT')
             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();
+        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. */
+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.');
+    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;
+    }
+    if (hasOwnedWorkContext())
+        setOwnedWorkAccount(currentUserId);
+    await reconcileInterruptedWork(p.client, p.identity.id);
+    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);
+    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();
+}
 async function heartbeat(p) {
+    if (p.heartbeating)
+        return;
+    p.heartbeating = true;
     try {
+        await heartbeatInner(p);
+    }
+    finally {
+        p.heartbeating = false;
+    }
+}
+async function heartbeatInner(p) {
+    if (cloudState === 'sign-in-required' && !shouldRebuildClient(p.builtFromRefreshToken, readSession()?.refresh_token))
+        return;
+    try {
+        if (p.readinessPending)
+            await restorePresenceWork(p);
         const { error } = await p.client
             .from('cliv2_agents')
             .upsert(buildPresenceHeartbeatPayload({
@@ -114,8 +236,10 @@ async function heartbeat(p) {
         }), { 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
@@ -139,8 +263,14 @@ async function heartbeat(p) {
                 // 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();
+                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
@@ -181,15 +311,12 @@ async function heartbeat(p) {
                    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;
-                }
+                await restorePresenceWork(p);
             }
         }
-        catch { /* stay down until the next tick */ }
+        catch (error) {
+            cloudState = error instanceof NotLoggedIn || confirmedSessionRejection(error) ? 'sign-in-required' : 'offline';
+        }
     }
     // Re-attempt agent registration each heartbeat for any detected agent still
     // idle or failed, while the tools server is up. Registration otherwise fires
@@ -248,6 +375,8 @@ async function cleanupSupersededRows(p) {
     }
 }
 async function pollCommands(p) {
+    if (cloudState !== 'online')
+        return;
     if (p.pollingCommands)
         return;
     p.pollingCommands = true;
@@ -314,6 +443,8 @@ async function pollCommands(p) {
  * daemon. Same reasoning as the heartbeat's per-tick `detectAgents()`.
  */
 async function pollOrchestrator(p) {
+    if (!mayClaim())
+        return;
     /* !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`
@@ -343,13 +474,16 @@ export async function startPresence() {
     }
     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 +508,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,
@@ -404,6 +548,14 @@ 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);
+        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);
+        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 +581,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 +617,13 @@ 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 reconcileInterruptedWork(p.client, p.identity.id);
+                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);
-            })();
+            })().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 +635,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 +654,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`
@@ -528,7 +687,6 @@ 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);
         return { machineName: identity.name, agents };
     })();
     try {
@@ -536,7 +694,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 +719,7 @@ export async function startPresence() {
 export async function stopPresence({ unregister = false } = {}) {
     if (stopping)
         return stopping;
+    presenceGeneration++;
     const p = presence;
     if (!p)
         return;
@@ -588,6 +747,7 @@ 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
@@ -614,6 +774,5 @@ export async function stopPresence({ unregister = false } = {}) {
     }
     finally {
         stopping = null;
-        releaseDaemonLock();
     }
 }

package/dist/supabase.js

@@ -7,6 +7,23 @@ export class NotLoggedIn extends Error {
         this.name = 'NotLoggedIn';
     }
 }
+/** A rejected credential is different from a request that never reached Auth. */
+export function confirmedSessionRejection(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const value = error;
+    return value.status === 401 || [
+        'refresh_token_not_found', 'refresh_token_already_used', 'session_not_found',
+        'session_expired', 'bad_jwt', 'user_not_found', 'invalid_credentials',
+    ].includes(value.code ?? '');
+}
+const sessionWriters = new WeakMap();
+/** Dispose the sole refresh writer before replacing it or abandoning startup. */
+export async function disposeClient(client) {
+    sessionWriters.get(client)?.unsubscribe();
+    sessionWriters.delete(client);
+    await client.auth.stopAutoRefresh();
+}
 /**
  * Sign in with email + password and persist the session to disk (shared with
  * the terminal CLI via session.json). Used by the companion GUI's sign-in form,
@@ -34,12 +51,17 @@ export async function signIn(email, password) {
  */
 const RETRY_DELAYS_MS = [250, 1000, 3000];
 const retryingFetch = async (input, init) => {
+    const supplied = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    const deadline = AbortSignal.timeout(20_000);
+    const signal = supplied ? AbortSignal.any([supplied, deadline]) : deadline;
     let lastErr;
     for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
         try {
-            return await fetch(input, init);
+            return await fetch(input, { ...init, signal });
         }
         catch (err) {
+            if (signal.aborted)
+                throw err;
             if (!(err instanceof TypeError))
                 throw err;
             lastErr = err;
@@ -94,7 +116,7 @@ export async function getClient({ refreshing = true } = {}) {
         auth: { persistSession: false, autoRefreshToken: true },
         global: { fetch: retryingFetch },
     });
-    client.auth.onAuthStateChange((_event, session) => {
+    const writer = client.auth.onAuthStateChange((_event, session) => {
         // Update-only: a token refresh must never recreate session.json after
         // `cs logout` deleted it, or the logged-out machine would re-authorize
         // itself up to an hour later.
@@ -102,14 +124,26 @@ export async function getClient({ refreshing = true } = {}) {
             writeSession({ access_token: session.access_token, refresh_token: session.refresh_token });
         }
     });
-    const { data, error } = await client.auth.setSession({
-        access_token: stored.access_token,
-        refresh_token: stored.refresh_token,
-    });
-    if (error || !data.session) {
-        throw new NotLoggedIn(`Stored session is invalid or expired (${error?.message ?? 'no session'}). Run \`cs login\` again.`);
+    sessionWriters.set(client, writer.data.subscription);
+    try {
+        const { data, error } = await client.auth.setSession({
+            access_token: stored.access_token,
+            refresh_token: stored.refresh_token,
+        });
+        if (error) {
+            if (confirmedSessionRejection(error)) {
+                throw new NotLoggedIn(`Stored sign-in was rejected (${error.message}). Run \`cs login\` again.`);
+            }
+            throw new Error(`Cloud sign-in could not be checked: ${error.message}`, { cause: error });
+        }
+        if (!data.session)
+            throw new Error('Cloud sign-in did not return a session. Try again when the connection is available.');
+        return client;
+    }
+    catch (error) {
+        await disposeClient(client);
+        throw error;
     }
-    return client;
 }
 /** Whether a stored access token's own `exp` claim has already passed. A token
  *  this process cannot parse is treated as unusable rather than trusted: the