@ctrl-spc/cs 0.7.15 → 0.7.16

package/dist/panel3/run.js

@@ -1,3 +1,4 @@
+import { failureMessage } from '../failure-reason.js';
 /**
  * ═══ AGENT PANEL v3: the poll loop that answers a card. ═══
  *
@@ -137,7 +138,7 @@ import { answerPrompt, escalationPrompt, levelOnePrompt, ownerActivationPrompt,
 import { ASK_CONTENT_COLUMNS, attachmentLine, gitRulesFor, loadAttachments, loadOutputNames, outputOf, recordBaseProtection, standingRulesFor, withAskContent, } from './show.js';
 import { forgetSecrets, redactSecrets } from './secrets.js';
 import { sayListening, sayPollingProblem, stopListening } from './presence.js';
-import { selectedHarness } from './coordinator.js';
+import { selectedHarness, recoveryHarnesses } from './coordinator.js';
 import { baseBranchState, checkoutForCodebase, commitCardWork, detectBaseProtection, folderIsBranch, hasCheckoutForCodebase, mergeIntoBase, releaseBaseBranch, settleCardWorktree, worktreeForCard, ownsReconciliation, prepareCardReconciliation, finishCardReconciliation, worktreesOnThisMachine, } from './checkout.js';
 import { harness, startAgent } from './spawn.js';
 import { establishOwnerSession, listOwnerSessionIds, OWNER_SESSION_GRACE_MS, readOwnerSession, removeOwnerSession, validSessionUuid, writeOwnerSession, } from './session.js';
@@ -155,10 +156,10 @@ import { join } from 'node:path';
 function recoveryAttempt(run) {
     return { runId: run.id, processToken: run.process_token, startedAt: run.started_at, resumedAt: run.resumed_at };
 }
-async function startTrackedAgent(client, runId, preparation, work, ...args) {
+async function startTrackedAgent(client, runId, preparation, work, captured, ...args) {
     if (!preparation)
-        return startAgent(...args);
-    const claimed = work?.claimAttempt(runId);
+        return { ...startAgent(...args), attempt: captured };
+    const claimed = captured ?? work?.claimAttempt(runId);
     if (!claimed)
         throw new Error('This run no longer belongs to the claimed attempt.');
     preparation.setAttempt(claimed);
@@ -207,7 +208,7 @@ async function startTrackedAgent(client, runId, preparation, work, ...args) {
         return answer;
     });
     void answered.catch(() => { }); // The caller records the PID before awaiting settlement.
-    return { ...started, answered, attempt: claimed, preparationFailed: () => preparationFailed };
+    return { ...started, answered, attempt: claimed, deferOutcome: preparation.deferOutcome, acknowledgeOutcome: preparation.acknowledgeOutcome, preparationFailed: () => preparationFailed };
 }
 function panelClaimAttempts(result) {
     if (!Array.isArray(result))
@@ -220,14 +221,15 @@ function panelClaimAttempts(result) {
         }
         unique.set(attempt.run_id, { runId: attempt.run_id, cardId: attempt.card_id, processToken: attempt.process_token ?? null,
             pid: attempt.pid ?? null, startedAt: attempt.started_at, resumedAt: attempt.resumed_at ?? null,
-            observedPendingTurnIds: attempt.observed_pending_turn_ids ?? null });
+            observedPendingTurnIds: attempt.observed_pending_turn_ids ?? null, authRecoveryRunId: attempt.auth_recovery_run_id ?? null, harness: attempt.harness ?? null });
     }
     return [...unique.values()];
 }
-async function panelClaim(client, work, action, args) {
-    if (!work)
-        return { ...await client.rpc(action, args), operationId: undefined };
-    const operationId = work.beginRpc(action);
+function capturedPanelAttempt(rows, runId, work) {
+    return work?.claimAttempt(runId) ?? panelClaimAttempts(rows).find(attempt => attempt.runId === runId);
+}
+async function panelClaim(client, work, action, args, nativeContext) {
+    const operationId = work?.beginRpc(action, { ...args, ...(nativeContext ? { nativeContext } : {}) }) ?? randomUUID();
     try {
         const response = await client.rpc(action, { ...args, p_operation_id: operationId });
         if (!response.error) {
@@ -237,14 +239,16 @@ async function panelClaim(client, work, action, args) {
             const row = journal.data?.[0];
             if (row?.outcome !== 'completed' || row.action !== action)
                 throw new Error('The claim was cancelled before it could start.');
-            work.recordRpc(operationId, panelClaimAttempts(row.result), false);
+            const attempts = panelClaimAttempts(row.result);
+            work?.recordRpc(operationId, attempts, false, row.result);
+            return { ...response, data: row.result, operationId };
         }
         if (response.error)
-            work.deferRpc(operationId);
+            work?.deferRpc(operationId);
         return { ...response, operationId };
     }
     catch (error) {
-        work.deferRpc(operationId);
+        work?.deferRpc(operationId);
         throw error;
     }
 }
@@ -252,7 +256,23 @@ async function reconcilePanelInterruptions(client, machineId, work) {
     const capability = await client.rpc('panel3_interrupt_machine_runs', { p_machine_id: machineId,
         p_operation_id: randomUUID(), p_interrupted_at: new Date().toISOString(), p_attempts: [] });
     if (capability.error)
-        throw capability.error;
+        throw new Error(`could not verify interruption recovery: ${capability.error.message}`);
+    for (const pending of work.pendingOutcomes()) {
+        const { attempt, outcome } = pending;
+        const { data, error } = await client.from('panel3_runs').select('started_at,resumed_at,process_token,state,ended_at,level,card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)').eq('id', attempt.runId).maybeSingle();
+        if (error)
+            throw new Error(`could not read the completed attempt: ${error.message}`);
+        if (data && data.started_at === attempt.startedAt && (data.resumed_at ?? null) === attempt.resumedAt
+            && (data.process_token ?? null) === attempt.processToken && data.ended_at === null) {
+            const card = (Array.isArray(data.card) ? data.card[0] : data.card);
+            const successfulToolEnding = !outcome.ok && outcome.failureKind !== 'authentication' && (data.state === 'asked' || (data.level === 1 && !!card?.conversation_run_id));
+            if (outcome.ok || successfulToolEnding)
+                await writeAnswer(client, attempt.runId, attempt.cardId, successfulToolEnding ? null : outcome.text, attempt.processToken ?? undefined, attempt);
+            else
+                await endRun(client, outcome.level ?? 1, attempt.runId, attempt.cardId, outcome.reason, attempt, outcome.failureKind);
+        }
+        work.acknowledgeOutcome(pending.id);
+    }
     for (const failure of work.failedPreparations()) {
         await endRun(client, failure.level, failure.attempt.runId, failure.attempt.cardId, failure.reason, failure.attempt);
         work.acknowledgePreparationFailure(failure.id);
@@ -260,12 +280,12 @@ async function reconcilePanelInterruptions(client, machineId, work) {
     for (const claim of work.pendingRpcs()) {
         const journal = await client.rpc('panel3_reconcile_claim', { p_machine_id: machineId, p_operation_id: claim.id });
         if (journal.error)
-            throw journal.error;
+            throw new Error(`could not read the claim receipt: ${journal.error.message}`);
         const row = journal.data?.[0];
         if (row?.outcome === 'cancelled')
             work.recordRpc(claim.id, [], true);
         else if (row?.outcome === 'completed' && row.action === claim.action)
-            work.recordRpc(claim.id, panelClaimAttempts(row.result), true);
+            work.recordRpc(claim.id, panelClaimAttempts(row.result), false, row.result);
         else
             throw new Error('The pending claim could not be reconciled.');
     }
@@ -742,11 +762,14 @@ async function recordProcess(client, runId, pid, brief, processToken, attempt) {
  * there first. It is a fact about the record rather than a failure, so it does
  * not go through `returned()`, exactly as the answer's own null does not.
  */
-async function giveUp(client, runId, reason, processToken, attempt) {
+async function giveUp(client, runId, reason, processToken, attempt, failureKind) {
     const { data, error } = await client
         .rpc('panel3_give_up', {
         p_run_id: runId,
         p_reason: reason,
+        p_failure_kind: failureKind ?? null,
+        p_process_token: processToken ?? null,
+        p_expected_attempt: null,
         ...(processToken === undefined ? {} : { p_process_token: processToken }),
         ...(attempt ? { p_process_token: attempt.processToken, p_expected_attempt: {
                 started_at: attempt.startedAt, resumed_at: attempt.resumedAt,
@@ -799,7 +822,7 @@ async function giveUp(client, runId, reason, processToken, attempt) {
  * a run can be the last thing live on it — but no turn is written, exactly as
  * none is written for a run that stopped to ask.
  */
-async function writeAnswer(client, runId, cardId, text, processToken) {
+async function writeAnswer(client, runId, cardId, text, processToken, attempt) {
     /* ═══ THE SECOND OF THE TWO CHOKEPOINTS THE CREDENTIAL RULE RESTS ON. ═══
        This is the ONE path an agent's own words take to a hosted row — a turn on
        the card at levels 1 and 2, and a level 3's `panel3_runs.report`, which
@@ -809,6 +832,9 @@ async function writeAnswer(client, runId, cardId, text, processToken) {
     const { data: turnId, error } = await client
         .rpc('panel3_answer', {
         p_run_id: runId,
+        p_process_token: processToken ?? attempt?.processToken ?? null,
+        p_expected_attempt: attempt ? { started_at: attempt.startedAt, resumed_at: attempt.resumedAt } : null,
+        p_auth_recovery_run_id: attempt?.authRecoveryRunId ?? null,
         p_body: text === null ? null : redactSecrets(processToken === undefined ? runId : `${runId}:${processToken}`, text),
         ...(processToken === undefined ? {} : { p_process_token: processToken }),
     });
@@ -876,14 +902,15 @@ async function writeAnswer(client, runId, cardId, text, processToken) {
                away. */
             said(`run ${runId} had already ended, so its answer was not written to card ${cardId}`);
         }
-        return ownerSettlementAccepted(run, processToken);
+        return ownerSettlementAccepted(run, processToken, attempt);
     }
     out(`answered card ${cardId}  run ${runId}  ${text?.length ?? 0} characters`);
     return true;
 }
-export function ownerSettlementAccepted(run, processToken) {
+export function ownerSettlementAccepted(run, processToken, attempt) {
     return (run.state === 'asked' || run.state === 'finished')
-        && (processToken === undefined || run.processToken === processToken);
+        && (processToken === undefined || run.processToken === processToken)
+        && (!attempt || run.processToken === attempt.processToken && run.startedAt === attempt.startedAt && (run.resumedAt ?? null) === attempt.resumedAt);
 }
 /** What the record says a run is now, and at what level. Read only to say the
  *  right sentence about something that has already happened; nothing branches on
@@ -891,7 +918,7 @@ export function ownerSettlementAccepted(run, processToken) {
 async function runNow(client, runId) {
     const runs = await returned(client
         .from('panel3_runs')
-        .select('state, level, process_token, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)')
+        .select('state, level, process_token, started_at, resumed_at, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)')
         .eq('id', runId), 'read', `the state of run ${runId}`);
     const run = runs[0];
     return run
@@ -899,9 +926,9 @@ async function runNow(client, runId) {
             state: run.state,
             level: run.level,
             conversationOwnerId: run.card?.conversation_run_id ?? null,
-            processToken: run.process_token,
+            processToken: run.process_token, startedAt: run.started_at, resumedAt: run.resumed_at,
         }
-        : { state: 'no longer on the record', level: null, conversationOwnerId: null, processToken: null };
+        : { state: 'no longer on the record', level: null, conversationOwnerId: null, processToken: null, startedAt: null, resumedAt: null };
 }
 /**
  * A run whose process failed, ended with the reason ON ITS OWN COLUMN, and its
@@ -1000,6 +1027,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
     const preparation = tools.work?.prepare(turns[0].run_id);
     try {
         const runId = turns[0].run_id;
+        const attempt = capturedPanelAttempt(turns, runId, tools.work);
         /* BEFORE THE SPAWN, AND ITS FAILURE IS THE SPAWN'S FAILURE. The receipts are
            part of what the agent is sent, so a read that fails must not be papered
            over with an empty list: that reads as a card that has made nothing, which
@@ -1043,7 +1071,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
-            await endRun(client, LEVEL, runId, cardId, why);
+            await endRun(client, LEVEL, runId, cardId, why, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${why}`);
         }
         /* ═══ THE RUN ID IS ON THE URL, AND THAT IS THE WHOLE OF WHAT THE AGENT IS
@@ -1055,7 +1083,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
         /* AN EMPTY DIRECTORY OF THE USER'S OWN, because level 1 has no code tool to
            use a real one with, and the daemon's inherited cwd under a launchd login
            item is the filesystem root. */
-        const started = await startTrackedAgent(client, runId, preparation, tools.work, withStandingRules(rules, brief, where.block), LEVEL, tools.urlFor(runId), where.cwd, undefined, settings);
+        const started = await startTrackedAgent(client, runId, preparation, tools.work, attempt, withStandingRules(rules, brief, where.block), LEVEL, tools.urlFor(runId), where.cwd, undefined, settings);
         out(`run      ${runId}  level ${LEVEL}  ${started.pid ? `pid ${started.pid}` : 'no process'}`);
         try {
             /* THE BRIEF, NOT WHAT THE PROCESS WAS HANDED. The rules are current at the
@@ -1399,11 +1427,11 @@ async function workingDirectory(client, runId, level, isOwner, knownCodebase) {
  * Then the row, then the process, then the pid — constraint 8, in the only order
  * that satisfies it.
  */
-async function startChild(client, tools, machineId, parentRunId, brief, codebase, parentProcessToken, choice = {}) {
+async function startChild(client, tools, machineId, parentRunId, brief, codebase, parentProcessToken, choice = {}, recovered) {
     let claimOperationId;
     const preparation = tools.work?.prepare();
     try {
-        const response = await panelClaim(client, tools.work, 'panel3_dispatch', {
+        const response = recovered ?? await panelClaim(client, tools.work, 'panel3_dispatch', {
             p_parent_run_id: parentRunId,
             p_brief: brief,
             p_machine_id: machineId,
@@ -1425,6 +1453,7 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
             throw new Error(`NO AGENT WAS STARTED and nothing was written: run ${parentRunId} has ended, is already as `
                 + 'deep as anything may be sent from, or this conversation already has its owner. Exit now.');
         }
+        const attempt = capturedPanelAttempt(data ?? [], row.run_id, tools.work);
         if (row.run_level !== 2 && row.run_level !== 3) {
             /* UNREACHABLE, AND STILL SETTLED. `panel3_dispatch` writes `parent.level + 1`
                from a parent it has just checked is below 3, so there is no level here
@@ -1433,7 +1462,7 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
                recovery sweep wait out the pid grace window to conclude what is already
                known. */
             const why = `run ${row.run_id} was written at level ${row.run_level}, which cannot be spawned`;
-            await giveUp(client, row.run_id, why, row.process_token ?? undefined);
+            await giveUp(client, row.run_id, why, row.process_token ?? undefined, attempt);
             throw new Error(why);
         }
         const level = row.run_level;
@@ -1459,12 +1488,12 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
-            await giveUp(client, row.run_id, why, row.process_token ?? undefined);
+            await giveUp(client, row.run_id, why, row.process_token ?? undefined, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${why}`);
         }
         const processToken = row.process_token ?? undefined;
         const isOwner = level === 2;
-        const started = await startTrackedAgent(client, row.run_id, preparation, tools.work, withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id, processToken), where.cwd, isOwner ? { ownerId: row.run_id } : undefined, settings);
+        const started = await startTrackedAgent(client, row.run_id, preparation, tools.work, attempt, withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id, processToken), where.cwd, isOwner ? { ownerId: row.run_id } : undefined, settings);
         if (started.pid === null) {
             if (started.interrupted?.())
                 throw new Error('Work was interrupted by the service command.');
@@ -1474,7 +1503,7 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
                and the tool call fails saying no agent was started. */
             const answer = await started.answered;
             const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
-            await giveUp(client, row.run_id, reason, processToken);
+            await giveUp(client, row.run_id, reason, processToken, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${reason}`);
         }
         out(`dispatch run ${row.run_id}  level ${level}  under ${parentRunId}  pid ${started.pid}`);
@@ -1565,12 +1594,13 @@ async function attemptsSoFar(client, runId) {
  * Returns whether THIS call is what ended it. False is a fact about the record,
  * not a failure: the run had already ended, and the caller says so.
  */
-async function endRun(client, level, runId, cardId, why, attempt) {
+async function endRun(client, level, runId, cardId, why, attempt, failureKind) {
     if (level !== 1)
-        return (await giveUp(client, runId, why, undefined, attempt)) !== null;
+        return (await giveUp(client, runId, why, undefined, attempt, failureKind)) !== null;
     if (attempt) {
         const { data, error } = await client.rpc('panel3_end_run', {
             p_run_id: runId, p_reason: why, p_process_token: attempt.processToken,
+            p_failure_kind: failureKind ?? null,
             p_expected_attempt: { started_at: attempt.startedAt, resumed_at: attempt.resumedAt },
         });
         if (error)
@@ -1666,6 +1696,11 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
     return started.answered.then(async (answer) => {
         if (started.interrupted?.() || started.preparationFailed?.())
             return;
+        if (!answer.ok)
+            answer = { ...answer, reason: failureMessage(started.attempt?.harness ?? harness(), answer.failureKind ?? 'unknown') };
+        started.deferOutcome?.({ surface: 'panel', ok: answer.ok,
+            text: answer.ok && speaksToTheCard ? redactSecrets(processToken === undefined ? runId : `${runId}:${processToken}`, answer.text) : null,
+            reason: answer.ok ? '' : answer.reason, failureKind: answer.ok ? undefined : answer.failureKind, level });
         /* ═══ A RUN THAT STOPPED TO ASK DID NOT DIE, WHATEVER THE HARNESS PRINTED
            ON ITS WAY OUT. ═══
     
@@ -1690,12 +1725,20 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
            into an ordinary ending, and then handed to `writeAnswer` — which already
            owns this case and already prints its sentence — rather than to a second
            ending written here beside it. */
-        if (!answer.ok) {
+        const observe = (authenticated) => {
+            const selected = started.attempt?.harness;
+            if (selected)
+                tools.work?.observeHarness(selected, authenticated ? 'authenticated' : 'sign-in-required', authenticated ? 'dispatch-success' : 'provider-rejected');
+        };
+        if (!answer.ok && answer.failureKind !== 'authentication') {
             const run = await runNow(client, runId);
             if (run.state === 'asked') {
-                const accepted = await writeAnswer(client, runId, cardId, null, processToken);
-                if (accepted)
+                started.deferOutcome?.({ surface: 'panel', ok: true, text: null, reason: '', level });
+                const accepted = await writeAnswer(client, runId, cardId, null, processToken, started.attempt);
+                if (accepted) {
+                    observe(true);
                     await ownerSession?.established();
+                }
                 else
                     await ownerSession?.failed();
                 return;
@@ -1705,7 +1748,9 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
                exit cleanly without an agent message after the tool succeeds. The
                record, not prose the launcher was told not to write, decides success. */
             if (level === 1 && run.conversationOwnerId !== null) {
-                await writeAnswer(client, runId, cardId, null, processToken);
+                started.deferOutcome?.({ surface: 'panel', ok: true, text: null, reason: '', level });
+                if (await writeAnswer(client, runId, cardId, null, processToken, started.attempt))
+                    observe(true);
                 return;
             }
         }
@@ -1716,7 +1761,7 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
                Repeating an invalid model/effort request cannot repair it. Unknown
                process deaths retain the existing recovery policy. */
             const attempts = await attemptsSoFar(client, runId);
-            if (answer.retryable !== false && started.pid !== null && attempts < MAX_ATTEMPTS) {
+            if (answer.retryable === true && started.pid !== null && attempts < MAX_ATTEMPTS) {
                 out(`retry    run ${runId}  attempt ${attempts} of ${MAX_ATTEMPTS} died: ${answer.reason}`);
                 const again = processToken === undefined
                     ? await resumeRun(client, tools, machineId, runId, started.pid)
@@ -1754,8 +1799,10 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
                than two. */
             const why = attempts > 1 ? `${answer.reason} (after ${attempts} attempts)` : answer.reason;
             const ended = processToken === undefined
-                ? await endRun(client, level, runId, cardId, why)
-                : (await giveUp(client, runId, why, processToken)) !== null;
+                ? await endRun(client, level, runId, cardId, why, started.attempt, answer.failureKind)
+                : (await giveUp(client, runId, why, processToken, started.attempt, answer.failureKind)) !== null;
+            if (ended && answer.failureKind === 'authentication')
+                observe(false);
             if (!ended) {
                 /* IT WAS ALREADY SETTLED, by recovery, which decided this process was
                    gone before it said so itself, or by the person's Stop. Nothing was
@@ -1772,12 +1819,14 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
         /* ═══ ITS OWN WORDS, ONTO THE CARD, THROUGH THE SAME STATEMENT EVERY LEVEL
            USES. ═══ Nothing reads them, nothing shortens them and nothing waits to
            approve them: ux.md's "whoever did the work writes the answer". */
-        const accepted = await writeAnswer(client, runId, cardId, speaksToTheCard ? answer.text : null, processToken);
-        if (accepted)
+        const accepted = await writeAnswer(client, runId, cardId, speaksToTheCard ? answer.text : null, processToken, started.attempt);
+        if (accepted) {
+            observe(true);
             await ownerSession?.established();
+        }
         else
             await ownerSession?.failed();
-    }).then(() => { started.completed?.(); });
+    }).then(() => { started.acknowledgeOutcome?.(); started.completed?.(); });
 }
 /**
  * ═══ ONE RUN, STARTED AGAIN AS ITSELF, WITH WHAT IT WAS SENT AND WHAT IT HAD
@@ -1835,7 +1884,7 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
  * the record refuses a fourth, and the caller is the one that knows what to say
  * about the failure it was holding.
  */
-async function resumeRun(client, tools, machineId, runId, afterPid) {
+async function resumeRun(client, tools, machineId, runId, afterPid, recovered) {
     /* ═══ THE SWEEP CHECKS BEFORE THE CLAIM AND THE RETRY CANNOT, AND `afterPid`
        IS THE WHOLE OF WHAT DECIDES IT. ═══ Said once, here. See the header for
        both halves of the argument: a machine with no checkout must not take a run
@@ -1853,7 +1902,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
     let claimOperationId;
     const preparation = tools.work?.prepare();
     try {
-        const response = await panelClaim(client, tools.work, 'panel3_resume', {
+        const response = recovered ?? await panelClaim(client, tools.work, 'panel3_resume', {
             p_run_id: runId,
             p_machine_id: machineId,
             p_after_pid: afterPid,
@@ -1865,6 +1914,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
         const claimed = data?.[0];
         if (!claimed)
             return null;
+        const attempt = capturedPanelAttempt(data ?? [], runId, tools.work);
         const level = claimed.run_level === 1 ? 1 : claimed.run_level === 2 ? 2 : 3;
         if (claimed.run_level !== level) {
             /* UNREACHABLE, AND STILL SETTLED, exactly as in `startChild`: the level
@@ -1872,7 +1922,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
                The claim has already happened, so leaving it would strand the run for a
                whole grace window before anything looked at it again. */
             const why = `run ${runId} is at level ${claimed.run_level}, which cannot be spawned`;
-            await giveUp(client, runId, why);
+            await giveUp(client, runId, why, undefined, attempt);
             throw new Error(why);
         }
         /* ONE RESOLUTION FOR BOTH PATHS, AFTER THE CLAIM. It used to fork on whether
@@ -1901,7 +1951,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
                1 here: handing the person's message back mints a new run with its
                attempts at one, which is the bound the retry is under, undone by the
                one path that could not start. See `endRun`. */
-            await endRun(client, level, runId, claimed.run_card_id, why);
+            await endRun(client, level, runId, claimed.run_card_id, why, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${level === 1 ? stderrOnly : why}`);
         }
         /* WHAT IT SENT OTHERS TO DO, FROM THE RECORD. Level 3 has no `dispatch`, so it
@@ -1942,14 +1992,14 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
-            await endRun(client, level, runId, claimed.run_card_id, why);
+            await endRun(client, level, runId, claimed.run_card_id, why, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${why}`);
         }
         /* ═══ WHY IT DIED IS WHAT DIFFERS, AND IT IS TOLD THE TRUTH ABOUT IT. ═══
              `resumePrompt` opens by saying the machine went down, which is true of the
              sweep and false of a retry: the daemon that watched this harness exit is
              still running. See `retryPrompt`. */
-        const started = await startTrackedAgent(client, runId, preparation, tools.work, withStandingRules(rules, afterPid === null
+        const started = await startTrackedAgent(client, runId, preparation, tools.work, attempt, withStandingRules(rules, afterPid === null
             ? resumePrompt(claimed.run_brief, claimed.run_report, children)
             : retryPrompt(claimed.run_brief, claimed.run_report, children), where.block, [], pictures), level, tools.urlFor(runId), where.cwd, undefined, settings);
         if (started.pid === null) {
@@ -1962,7 +2012,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
             const answer = await started.answered;
             const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
             // The same level fork, for the same reason. See `endRun`.
-            await endRun(client, level, runId, claimed.run_card_id, reason);
+            await endRun(client, level, runId, claimed.run_card_id, reason, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${reason}`);
         }
         out(`resume   run ${runId}  level ${level}  pid ${started.pid}  `
@@ -2012,10 +2062,11 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
 async function startRearmed(client, tools, machineId, row) {
     const preparation = tools.work?.prepare(row.run_id);
     try {
+        const attempt = capturedPanelAttempt([row], row.run_id, tools.work);
         const level = row.run_level === 1 ? 1 : row.run_level === 2 ? 2 : 3;
         if (row.run_level !== level) {
             const why = `run ${row.run_id} is at level ${row.run_level}, which cannot be spawned`;
-            await giveUp(client, row.run_id, why);
+            await giveUp(client, row.run_id, why, undefined, attempt);
             throw new Error(why);
         }
         let where;
@@ -2036,7 +2087,7 @@ async function startRearmed(client, tools, machineId, row) {
             // The level fork, which this path needs for the same reason `resumeRun`'s
             // two do: a re-arm serves level 1, and a level 1 run holds the person's
             // message. See `endRun`.
-            await endRun(client, level, row.run_id, row.run_card_id, why);
+            await endRun(client, level, row.run_id, row.run_card_id, why, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${level === 1 ? said : why}`);
         }
         /* WHAT IT SENT OTHERS TO DO AND WHAT THEY WROTE, FROM THE RECORD, AS LATE AS
@@ -2077,17 +2128,17 @@ async function startRearmed(client, tools, machineId, row) {
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
-            await endRun(client, level, row.run_id, row.run_card_id, why);
+            await endRun(client, level, row.run_id, row.run_card_id, why, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${why}`);
         }
-        const started = await startTrackedAgent(client, row.run_id, preparation, tools.work, withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id), where.cwd, undefined, settings);
+        const started = await startTrackedAgent(client, row.run_id, preparation, tools.work, attempt, withStandingRules(rules, prompt, where.block, [], pictures), level, tools.urlFor(row.run_id), where.cwd, undefined, settings);
         if (started.pid === null) {
             if (started.interrupted?.())
                 throw new Error('Work was interrupted by the service command.');
             const answer = await started.answered;
             const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
             // The same level fork, for the same reason. See `endRun`.
-            await endRun(client, level, row.run_id, row.run_card_id, reason);
+            await endRun(client, level, row.run_id, row.run_card_id, reason, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${reason}`);
         }
         out(`rearm    run ${row.run_id}  level ${level}  pid ${started.pid}  `
@@ -2269,7 +2320,7 @@ export function resumableOwnerSessionId(candidate, machineId, machineHarness) {
         ? local.nativeSessionId
         : undefined;
 }
-async function activateOwner(client, tools, machineId, runId, afterProcessToken = null, afterPid = null) {
+async function activateOwner(client, tools, machineId, runId, afterProcessToken = null, afterPid = null, recovered) {
     let claimOperationId;
     const preparation = tools.work?.prepare();
     try {
@@ -2283,7 +2334,13 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
         const machineHarness = candidate.handed_back_at === null && candidate.harness !== null
             ? harness({ CTRL_SPC_V3_AGENT: candidate.harness })
             : await selectedHarness(client, machineId);
-        const resumeSessionId = resumableOwnerSessionId(candidate, machineId, machineHarness);
+        if (recovered?.nativeContext && (recovered.nativeContext.harness !== machineHarness || recovered.nativeContext.processToken !== null && typeof recovered.nativeContext.processToken !== 'string' || recovered.nativeContext.nativeSessionId !== undefined && typeof recovered.nativeContext.nativeSessionId !== 'string'))
+            throw new Error('The saved native conversation context is invalid.');
+        const resumeSessionId = recovered?.nativeContext
+            ? resumableOwnerSessionId({ ...candidate, process_token: recovered.nativeContext.processToken }, machineId, recovered.nativeContext.harness)
+            : resumableOwnerSessionId(candidate, machineId, machineHarness);
+        if (recovered?.nativeContext?.nativeSessionId && resumeSessionId !== recovered.nativeContext.nativeSessionId)
+            throw new Error('The saved native conversation is no longer available for this attempt.');
         /* ═══ THE EXISTENCE CHECK BEFORE THE CLAIM, AND THE COPY AFTER IT. ═══ This
            was the whole resolution, which was right while resolving meant reading a
            folder out of a file. Since worktrees-8 it also CREATES one, and a daemon
@@ -2294,13 +2351,13 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
         if (candidate.codebase_id !== null) {
             checkoutForCodebase(await codebaseOfRun(client, candidate.id), hostname());
         }
-        const response = await panelClaim(client, tools.work, 'panel3_take_owner_activation', {
+        const response = recovered ?? await panelClaim(client, tools.work, 'panel3_take_owner_activation', {
             p_run_id: runId,
             p_machine_id: machineId,
             p_agent: machineHarness,
             p_after_process_token: afterProcessToken,
             p_after_pid: afterPid,
-        });
+        }, { nativeSessionId: resumeSessionId, processToken: candidate.process_token, harness: machineHarness });
         const { data, error, operationId } = response;
         claimOperationId = operationId;
         if (error)
@@ -2308,6 +2365,7 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
         const claimed = data?.[0];
         if (!claimed)
             return null;
+        const attempt = capturedPanelAttempt(data ?? [], runId, tools.work);
         const [events, children] = await Promise.all([
             ownerConversation(client, claimed.run_card_id, new Set(claimed.turn_ids ?? [])),
             ownerChildren(client, runId),
@@ -2370,7 +2428,7 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
-            await giveUp(client, runId, why, claimed.process_token);
+            await giveUp(client, runId, why, claimed.process_token, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${why}`);
         }
         /* THE MERGE, OFF THE MARK ON THE ASK, BEFORE THE AGENT THAT WILL SPEAK ABOUT
@@ -2391,13 +2449,13 @@ async function activateOwner(client, tools, machineId, runId, afterProcessToken
             : ownerActivationPrompt(claimed.run_brief, claimed.run_report, events, children, delivered !== null && !delivered.mine
                 ? { id: delivered.id, question: delivered.question }
                 : null, currentArtifactAnswer, afterPid !== null, landing);
-        const started = await startTrackedAgent(client, runId, preparation, tools.work, withStandingRules(rules, prompt, where.block, attached, pictures), 2, tools.urlFor(runId, claimed.process_token), where.cwd, { ownerId: runId, ...(resumeSessionId ? { resumeSessionId } : {}) }, settings);
+        const started = await startTrackedAgent(client, runId, preparation, tools.work, attempt, withStandingRules(rules, prompt, where.block, attached, pictures), 2, tools.urlFor(runId, claimed.process_token), where.cwd, { ownerId: runId, ...(resumeSessionId ? { resumeSessionId } : {}) }, settings);
         if (started.pid === null) {
             if (started.interrupted?.())
                 throw new Error('Work was interrupted by the service command.');
             const answer = await started.answered;
             const reason = answer.ok ? 'the process ended before it could be identified' : answer.reason;
-            await giveUp(client, runId, reason, claimed.process_token);
+            await giveUp(client, runId, reason, claimed.process_token, attempt);
             throw new Error(`NO AGENT IS RUNNING: ${reason}`);
         }
         try {
@@ -3324,6 +3382,7 @@ export async function run(args, injected, signal, lifecycle, work) {
     const machineId = getMachineIdentity().id;
     const machineName = hostname();
     let listeningHarness = null;
+    const listeningRoutes = new Set();
     /* THE RUNS THIS PROCESS IS HOLDING RIGHT NOW, so recovery cannot declare its
        own live work dead in the moment before a pid is recorded. It covers THIS
        daemon only, which is why `PID_GRACE_MS` exists for the other ones. Keyed by
@@ -3349,9 +3408,10 @@ export async function run(args, injected, signal, lifecycle, work) {
        `tools` is referenced inside the callback it is being given, which is safe
        for the plain reason that the callback can only run once a request has
        arrived at a server that by then exists. */
+    if (work && !work.cloudAllowed())
+        throw new Error('Cloud operations are suspended for this sign-in.');
     if (work)
         await reconcilePanelInterruptions(current(), machineId, work);
-    lifecycle?.reconciled?.();
     const tools = await startToolsServer(current(), async (parentRunId, brief, codebase, processToken, choice) => {
         const endClaim = work?.beginClaim();
         try {
@@ -3418,9 +3478,18 @@ export async function run(args, injected, signal, lifecycle, work) {
                `--once` still fails loudly, because the acceptance harness reads the exit
                code and a swallowed failure there would make a broken suite look green. */
             try {
+                if (work && !work.cloudAllowed()) {
+                    await sleep(POLL_INTERVAL_MS);
+                    continue;
+                }
                 if (work)
                     await reconcilePanelInterruptions(current(), machineId, work);
                 if (work && !work.allowed()) {
+                    // A successful read proves polling before recovery opens admission.
+                    const { error } = await current().from('panel3_cards').select('id').limit(1);
+                    if (error)
+                        throw error;
+                    lifecycle?.ready();
                     await sleep(POLL_INTERVAL_MS);
                     continue;
                 }
@@ -3431,30 +3500,96 @@ export async function run(args, injected, signal, lifecycle, work) {
                    to run first: `panel3_stop_card` has already ended the runs, so recovery
                    cannot see them and neither take can start them. */
                 await killStopped(current(), machineId, work);
+                for (const claim of work?.recoveredClaims() ?? []) {
+                    const attempts = panelClaimAttempts(claim.result);
+                    const eligible = new Set();
+                    for (const attempt of attempts) {
+                        if (inFlight.has(attempt.runId))
+                            continue;
+                        const pending = work?.claimAttempt(attempt.runId);
+                        if (!pending)
+                            continue; // Preparation or an actual stop already owns it.
+                        const { data, error } = await current().from('panel3_runs')
+                            .select('started_at,resumed_at,process_token,state,ended_at').eq('id', attempt.runId).maybeSingle();
+                        if (error)
+                            throw error;
+                        if (data?.state === 'running' && data.ended_at === null && data.started_at === attempt.startedAt
+                            && (data.resumed_at ?? null) === attempt.resumedAt && (data.process_token ?? null) === attempt.processToken)
+                            eligible.add(attempt.runId);
+                    }
+                    const rows = (claim.result ?? []).filter((row) => eligible.has(row._attempt?.run_id ?? row.run_id));
+                    const response = { data: rows, error: null, operationId: claim.id, nativeContext: claim.args?.nativeContext };
+                    const args = claim.args ?? {};
+                    if (rows.length) {
+                        if (claim.action === 'panel3_take_turns') {
+                            for (const [cardId, turns] of byCard(rows))
+                                hold(turns[0].run_id, answerCard(current(), tools, machineId, cardId, turns));
+                        }
+                        else if (claim.action === 'panel3_take_rearms') {
+                            for (const row of rows) {
+                                const started = await startRearmed(current(), tools, machineId, row);
+                                hold(row.run_id, started.settled);
+                            }
+                        }
+                        else if (claim.action === 'panel3_dispatch') {
+                            const row = rows[0];
+                            const codebase = args.p_codebase_id ? await codebaseOfRun(current(), row.run_id) : null;
+                            const started = await startChild(current(), tools, machineId, String(args.p_parent_run_id), String(args.p_brief), codebase, typeof args.p_process_token === 'string' ? args.p_process_token : undefined, {}, response);
+                            hold(started.runId, started.settled);
+                        }
+                        else if (claim.action === 'panel3_resume') {
+                            const runId = String(args.p_run_id);
+                            const started = await resumeRun(current(), tools, machineId, runId, typeof args.p_after_pid === 'number' ? args.p_after_pid : null, response);
+                            if (started)
+                                hold(runId, started.settled);
+                        }
+                        else if (claim.action === 'panel3_take_owner_activation') {
+                            const runId = String(args.p_run_id);
+                            const started = await activateOwner(current(), tools, machineId, runId, typeof args.p_after_process_token === 'string' ? args.p_after_process_token : null, typeof args.p_after_pid === 'number' ? args.p_after_pid : null, response);
+                            if (started)
+                                hold(runId, started.settled);
+                        }
+                        else
+                            throw new Error('The saved panel claim has an unsupported action.');
+                    }
+                    work?.finishRpcs([claim.id]);
+                }
                 /* Publish readiness before claiming work. A card with an untaken turn reads the same whether a daemon
                    is two seconds away or nobody has one running; this row is the only place
                    the difference exists. It is written before the takes rather than after
                    so that a machine which is up but busy still reads as up. */
-                // Resolve before claiming work. A failed read or missing binary must not
-                // leave the previous agent advertised as ready for new assignments.
-                let machineHarness;
-                try {
-                    machineHarness = await selectedHarness(current(), machineId);
+                const installed = recoveryHarnesses();
+                for (const route of [...listeningRoutes]) {
+                    if (!installed.includes(route)) {
+                        await stopListening(current(), machineId, route);
+                        listeningRoutes.delete(route);
+                    }
                 }
-                catch (error) {
-                    if (listeningHarness !== null) {
-                        await stopListening(current(), machineId, listeningHarness);
-                        listeningHarness = null;
+                // A primary selection failure cannot skip an installed recovery route.
+                for (const route of installed) {
+                    try {
+                        const response = await panelClaim(current(), work, 'panel3_take_turns', { p_machine_id: machineId, p_agent: route, p_recovery_only: true });
+                        if (response.operationId)
+                            claimOperations.push(response.operationId);
+                        const taken = await returned(Promise.resolve(response), 'take', 'explicit authentication recovery');
+                        await sayListening(current(), machineId, machineName, route);
+                        await sayPollingProblem(current(), machineId, route, null);
+                        listeningRoutes.add(route);
+                        for (const [cardId, turns] of byCard(taken))
+                            hold(turns[0].run_id, answerCard(current(), tools, machineId, cardId, turns));
+                    }
+                    catch (error) {
+                        try {
+                            await sayPollingProblem(current(), machineId, route, 'poll_failed');
+                        }
+                        catch { /* The last successful observation expires. */ }
+                        said(`Authentication recovery polling failed for ${route}: ${error instanceof Error ? error.message : String(error)}`);
                     }
-                    throw error;
                 }
+                const machineHarness = await selectedHarness(current(), machineId);
+                listeningHarness = machineHarness;
                 if (signal?.aborted)
                     break;
-                if (listeningHarness !== null && listeningHarness !== machineHarness) {
-                    await stopListening(current(), machineId, listeningHarness);
-                }
-                listeningHarness = machineHarness;
-                await sayListening(current(), machineId, machineName, machineHarness);
                 await reconcileOwnerSessions(current(), machineId, machineHarness, new Set(inFlight.keys()), work);
                 await recoverStranded(current(), tools, machineId, new Set(inFlight.keys()), hold);
                 /* ═══ AND THE COPIES OF CARDS THAT ARE OVER. ═══ After recovery,
@@ -3481,7 +3616,7 @@ export async function run(args, injected, signal, lifecycle, work) {
                 /* THE MACHINE ID GOES IN because the take writes the run row, and a run has
                    to say where it is running: the exclusion is cross-machine and recovery is
                    per-machine, so a row with nobody's machine on it could be neither. */
-                const takenResponse = await panelClaim(current(), work, 'panel3_take_turns', { p_machine_id: machineId, p_agent: machineHarness });
+                const takenResponse = await panelClaim(current(), work, 'panel3_take_turns', { p_machine_id: machineId, p_agent: machineHarness, p_recovery_only: false });
                 if (takenResponse.operationId)
                     claimOperations.push(takenResponse.operationId);
                 const taken = await returned(Promise.resolve(takenResponse), 'take', 'turns');
@@ -3529,6 +3664,8 @@ export async function run(args, injected, signal, lifecycle, work) {
                     // rather than becoming an unhandled rejection.
                     hold(runId, answerCard(current(), tools, machineId, cardId, turns));
                 }
+                await sayListening(current(), machineId, machineName, machineHarness);
+                listeningRoutes.add(machineHarness);
                 await sayPollingProblem(current(), machineId, machineHarness, null);
                 lifecycle?.ready();
                 if (once) {
@@ -3565,8 +3702,8 @@ export async function run(args, injected, signal, lifecycle, work) {
     }
     finally {
         try {
-            if (listeningHarness !== null)
-                await stopListening(current(), machineId, listeningHarness);
+            for (const route of listeningRoutes)
+                await stopListening(current(), machineId, route);
         }
         finally {
             await tools.close();
@@ -3602,8 +3739,7 @@ export function startPanel(injected, work) {
                         }
                         return false;
                     },
-                    reconciled: () => resolveReady(),
-                    ready: () => { if (!requested)
+                    ready: () => { resolveReady(); if (!requested)
                         resolveRestart?.(); },
                 }, work);
             }