@ctrl-spc/cs 0.7.0 → 0.7.1

package/dist/panel3/run.js

@@ -132,16 +132,18 @@
 // and takes the leading comment with it, so a file whose first statement is
 // `import type` loses its v3 header in the published `dist/`.
 import { out, returned, signedInClient } from './client.js';
-import { answerPrompt, escalationPrompt, levelOnePrompt, readBackPrompt, resumePrompt, retryPrompt, } from './prompt.js';
-import { attachmentLine, loadAttachments, loadOutputNames, outputOf } from './show.js';
+import { answerPrompt, escalationPrompt, levelOnePrompt, ownerActivationPrompt, readBackPrompt, presentedArtifactAnswerContext, resumePrompt, retryPrompt, } from './prompt.js';
+import { ASK_CONTENT_COLUMNS, attachmentLine, loadAttachments, loadOutputNames, outputOf, withAskContent, } from './show.js';
 import { forgetSecrets, redactSecrets } from './secrets.js';
 import { sayListening, stopListening } from './presence.js';
 import { checkoutForCodebase, hasCheckoutForCodebase } from './checkout.js';
 import { harness, startAgent } from './spawn.js';
+import { establishOwnerSession, listOwnerSessionIds, OWNER_SESSION_GRACE_MS, readOwnerSession, removeOwnerSession, validSessionUuid, writeOwnerSession, } from './session.js';
 import { startToolsServer } from './tools.js';
+import { listPanel3CodexOwnerHomeIds, removePanel3CodexOwnerHome, } from '../codex-home.js';
 import { getMachineIdentity, scratchDir } from '../config.js';
 import { listCodebases } from '../codebases.js';
-import { processIsAlive } from '../win-shell.js';
+import { killTree, processIsAlive } from '../win-shell.js';
 import { hostname, uptime } from 'node:os';
 const USAGE = 'usage: cs3 run [--once]';
 /** How long between takes. Short, because it is the whole delay between a user
@@ -200,6 +202,28 @@ export const MAX_ATTEMPTS = 3;
  *  because an agent asked for it, and its level comes off the row
  *  `panel3_dispatch` wrote rather than from anything here. */
 const LEVEL = 1;
+const artifactAnswer = (id, revision, selected) => {
+    if (!id || revision === null || revision === undefined || selected?.length !== 1)
+        return null;
+    const answer = selected[0]?.trim().toLowerCase();
+    return answer === 'approve' || answer === 'request changes'
+        ? { id, revision, answer }
+        : null;
+};
+export function deliveredArtifactAnswer(events, delivered) {
+    if (!delivered.mine || delivered.ask_id === null)
+        return null;
+    const event = events.find((candidate) => candidate.kind === 'question' && candidate.id === delivered.ask_id);
+    const answer = artifactAnswer(event?.relatedArtifactId, event?.relatedArtifactRevision, event?.artifactAnswer ? [event.artifactAnswer] : null);
+    return answer === null ? null : { questionId: delivered.ask_id, ...answer };
+}
+async function rearmedArtifactAnswer(client, askId) {
+    const asks = await withAskContent(client, await returned(client.from('panel3_asks').select(`id, ${ASK_CONTENT_COLUMNS}`).eq('id', askId), 'read', `question ${askId}`));
+    const ask = asks[0];
+    return ask === undefined
+        ? null
+        : artifactAnswer(ask.related_artifact_id, ask.related_artifact_revision, ask.selected_options);
+}
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * ═══ NOTHING IN THIS FILE STAMPS A COLUMN FROM THIS MACHINE'S CLOCK ANY MORE,
@@ -344,12 +368,16 @@ export const briefFor = (title, turns, produced, attachments, codebases = null)
  * the run has no pid, so once this daemon is gone recovery treats it as dead —
  * which errs towards answering again rather than stranding.
  */
-async function recordProcess(client, runId, pid, brief) {
-    await returned(client
+async function recordProcess(client, runId, pid, brief, processToken) {
+    let query = client
         .from('panel3_runs')
         .update({ pid, ...(brief === undefined ? {} : { brief }) })
-        .eq('id', runId)
-        .select('id'), 'record what is running', `run ${runId}`);
+        .eq('id', runId);
+    if (processToken !== undefined)
+        query = query.eq('process_token', processToken);
+    const written = await returned(query.select('id'), 'record what is running', `run ${runId}`);
+    if (written.length === 0)
+        throw new Error(`could not record what is running for run ${runId}: its activation has ended`);
 }
 /**
  * ═══ A RUN GIVEN UP ON: ENDED, ITS TURNS HANDED BACK, ITS CARD IN HAND. ═══
@@ -364,15 +392,19 @@ async function recordProcess(client, runId, pid, brief) {
  * 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) {
+async function giveUp(client, runId, reason, processToken) {
     const { data, error } = await client
-        .rpc('panel3_give_up', { p_run_id: runId, p_reason: reason });
+        .rpc('panel3_give_up', {
+        p_run_id: runId,
+        p_reason: reason,
+        ...(processToken === undefined ? {} : { p_process_token: processToken }),
+    });
     if (error)
         throw new Error(`could not give up run ${runId}: ${error.message}`);
     /* THE RUN IS OVER, so whatever it read is dropped. Every ending does this —
        here, `failRun` and `writeAnswer` — because a daemon stays up for days and
        has no business holding Tuesday's secret. */
-    forgetSecrets(runId);
+    forgetSecrets(processToken === undefined ? runId : `${runId}:${processToken}`);
     return data;
 }
 /**
@@ -411,7 +443,7 @@ async function giveUp(client, runId, reason) {
  * 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) {
+async function writeAnswer(client, runId, cardId, text, processToken) {
     /* ═══ 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
@@ -419,7 +451,11 @@ async function writeAnswer(client, runId, cardId, text) {
        `buildServer`. Identity for a run that read no credential, so every existing
        exact-string assertion is byte-identical. */
     const { data: turnId, error } = await client
-        .rpc('panel3_answer', { p_run_id: runId, p_body: text === null ? null : redactSecrets(runId, text) });
+        .rpc('panel3_answer', {
+        p_run_id: runId,
+        p_body: text === null ? null : redactSecrets(processToken === undefined ? runId : `${runId}:${processToken}`, text),
+        ...(processToken === undefined ? {} : { p_process_token: processToken }),
+    });
     if (error) {
         /* Thrown, not settled as failed. The run stays `running` with a process
            that has now exited, so recovery reaps it: at level 1 the turns are
@@ -433,7 +469,7 @@ async function writeAnswer(client, runId, cardId, text) {
        credential again through `get_credential`. What it is handed to start from —
        its own report, and the card — went through this same substitution, so there
        is nothing left for a stale entry to protect. */
-    forgetSecrets(runId);
+    forgetSecrets(processToken === undefined ? runId : `${runId}:${processToken}`);
     if (turnId === null) {
         /* NO TURN WAS WRITTEN, and there are FOUR reasons, which mean different
            things and must not be printed as one line.
@@ -469,6 +505,9 @@ async function writeAnswer(client, runId, cardId, text) {
         else if (run.state !== 'finished') {
             said(`run ${runId} was ${run.state}, so its answer was not written to card ${cardId}`);
         }
+        else if (run.level === 1 && run.conversationOwnerId !== null) {
+            out(`settled  card ${cardId}  run ${runId}  assigned the conversation, so it wrote nothing here`);
+        }
         else if (text === null) {
             out(`settled  card ${cardId}  run ${runId}  answered a question, so it wrote nothing here`);
         }
@@ -481,16 +520,32 @@ async function writeAnswer(client, runId, cardId, text) {
                away. */
             said(`run ${runId} had already ended, so its answer was not written to card ${cardId}`);
         }
-        return;
+        return ownerSettlementAccepted(run, processToken);
     }
     out(`answered card ${cardId}  run ${runId}  ${text?.length ?? 0} characters`);
+    return true;
+}
+export function ownerSettlementAccepted(run, processToken) {
+    return (run.state === 'asked' || run.state === 'finished')
+        && (processToken === undefined || run.processToken === processToken);
 }
 /** 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
  *  it that could have gone the other way. */
 async function runNow(client, runId) {
-    const runs = await returned(client.from('panel3_runs').select('state, level').eq('id', runId), 'read', `the state of run ${runId}`);
-    return runs[0] ?? { state: 'no longer on the record', level: null };
+    const runs = await returned(client
+        .from('panel3_runs')
+        .select('state, level, process_token, 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
+        ? {
+            state: run.state,
+            level: run.level,
+            conversationOwnerId: run.card?.conversation_run_id ?? null,
+            processToken: run.process_token,
+        }
+        : { state: 'no longer on the record', level: null, conversationOwnerId: null, processToken: null };
 }
 /**
  * A run whose process failed, ended with the reason ON ITS OWN COLUMN, and its
@@ -583,7 +638,29 @@ async function answerCard(client, tools, machineId, cardId, turns) {
        attachments read carries the same rule: a failed read here must not read
        as "nothing is attached", which is a different card than the one that was
        actually sent. */
-    const brief = briefFor(turns[0].card_title, turns, await receiptsFor(client, cardId), await attachmentsFor(client, cardId), await codebasesForRun(client, runId));
+    /* ═══ AND A FAILURE HERE ENDS THE RUN, RATHER THAN LEAVING IT RUNNING WITH NO
+       PROCESS. ═══ The take already wrote the run row in the statement that leased
+       the turns, so a throw between here and `startAgent` leaves a run reading
+       `running` with a null pid and nothing on stderr the person can see.
+       `recoverStranded` then reads that as a machine that went away, hands the
+       message back, and `panel3_take_turns` leases it to A BRAND NEW RUN whose
+       attempts start again at one — so a permanent failure, such as a read this
+       build cannot make against the current schema, repeats forever while the card
+       says Working and never says why. This is the sixth of `endRun`'s endings and
+       the last one that was missing: `resumeRun` and `startRearmed` already end
+       their two post-claim failures this way for exactly this reason.
+       THE REASON IS SHAREABLE. All three reads are `returned()` calls against the
+       database, whose messages name tables and columns and never a local path, so
+       constraint 6 is satisfied without a level fork here. */
+    let brief;
+    try {
+        brief = briefFor(turns[0].card_title, turns, await receiptsFor(client, cardId), await attachmentsFor(client, cardId), await codebasesForRun(client, runId));
+    }
+    catch (error) {
+        const why = error instanceof Error ? error.message : String(error);
+        await endRun(client, LEVEL, runId, cardId, why);
+        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
        TOLD ABOUT ITS OWN STANDING. ═══ The tools server reads the level off the
        run row this id names, so the daemon does not tell the child what it may do
@@ -603,7 +680,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
         // agent is not killed over it.
         said(`${error instanceof Error ? error.message : String(error)} (the run is still going)`);
     }
-    return settle(client, tools, machineId, LEVEL, runId, cardId, started);
+    return settle(client, tools, machineId, LEVEL, runId, cardId, started, false);
 }
 /**
  * WHICH PROJECT A RUN'S CARD IS FILED UNDER, or null when the card has none.
@@ -620,7 +697,7 @@ async function answerCard(client, tools, machineId, cardId, turns) {
  * project's code.
  */
 async function projectOfRun(client, runId) {
-    const rows = await returned(client.from('panel3_runs').select('card:panel3_cards(project_id)').eq('id', runId), 'read', 'which project this run belongs to');
+    const rows = await returned(client.from('panel3_runs').select('card:panel3_cards!panel3_runs_card_id_fkey(project_id)').eq('id', runId), 'read', 'which project this run belongs to');
     return rows[0]?.card?.project_id ?? null;
 }
 async function codebasesForRun(client, runId) {
@@ -630,7 +707,7 @@ async function codebasesForRun(client, runId) {
 async function codebaseOfRun(client, runId) {
     const rows = await returned(client
         .from('panel3_runs')
-        .select('codebase_id, card:panel3_cards(project_id)')
+        .select('codebase_id, card:panel3_cards!panel3_runs_card_id_fkey(project_id)')
         .eq('id', runId), 'read', `which codebase run ${runId} belongs to`);
     const row = rows[0];
     if (!row?.codebase_id || !row.card?.project_id) {
@@ -643,6 +720,17 @@ async function codebaseOfRun(client, runId) {
     }
     return codebase;
 }
+/** One directory rule for every spawn whose level and ownership are known. */
+async function workingDirectory(client, runId, level, isOwner, knownCodebase) {
+    if (level === 1)
+        return scratchDir();
+    if (knownCodebase === null) {
+        if (level === 2 && isOwner)
+            return scratchDir();
+        throw new Error('This code work does not name a registered project codebase.');
+    }
+    return checkoutForCodebase(knownCodebase ?? await codebaseOfRun(client, runId), hostname());
+}
 /**
  * ═══ ONE AGENT, STARTED UNDER ANOTHER THAT IS STILL RUNNING. ═══
  *
@@ -658,13 +746,14 @@ async function codebaseOfRun(client, runId) {
  * 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) {
+async function startChild(client, tools, machineId, parentRunId, brief, codebase, parentProcessToken) {
     const { data, error } = await client.rpc('panel3_dispatch', {
         p_parent_run_id: parentRunId,
         p_brief: brief,
         p_machine_id: machineId,
-        p_codebase_id: codebase.id,
-        p_codebase_label: codebase.name,
+        p_codebase_id: codebase?.id ?? null,
+        p_codebase_label: codebase?.name ?? null,
+        ...(parentProcessToken === undefined ? {} : { p_process_token: parentProcessToken }),
     });
     if (error)
         throw new Error(`could not start an agent under run ${parentRunId}: ${error.message}`);
@@ -673,8 +762,8 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
         /* NOTHING WAS WRITTEN AND NOTHING IS RUNNING, and the two reasons are said
            together because the caller cannot tell them apart from here and both mean
            the same thing to it. */
-        throw new Error(`NO AGENT WAS STARTED and nothing was written: run ${parentRunId} has ended, or it is already `
-            + 'as deep as anything may be sent from.');
+        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.');
     }
     if (row.run_level !== 2 && row.run_level !== 3) {
         /* UNREACHABLE, AND STILL SETTLED. `panel3_dispatch` writes `parent.level + 1`
@@ -684,20 +773,26 @@ 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);
+        await giveUp(client, row.run_id, why, row.process_token ?? undefined);
         throw new Error(why);
     }
     const level = row.run_level;
     let cwd;
+    let prompt;
     try {
-        cwd = checkoutForCodebase(codebase, hostname());
+        cwd = await workingDirectory(client, row.run_id, level, level === 2, codebase);
+        prompt = level === 2
+            ? await initialOwnerPrompt(client, row.run_card_id, parentRunId, brief)
+            : brief;
     }
     catch (error) {
         const why = error instanceof Error ? error.message : String(error);
-        await giveUp(client, row.run_id, why);
+        await giveUp(client, row.run_id, why, row.process_token ?? undefined);
         throw new Error(`NO AGENT IS RUNNING: ${why}`);
     }
-    const started = startAgent(brief, level, tools.urlFor(row.run_id), cwd);
+    const processToken = row.process_token ?? undefined;
+    const isOwner = level === 2;
+    const started = startAgent(prompt, level, tools.urlFor(row.run_id, processToken), cwd, isOwner ? { ownerId: row.run_id } : undefined);
     if (started.pid === null) {
         /* THERE IS A ROW AND THERE IS NO PROCESS, which is the one shape the record
            must never be left in quietly. The answer is already settled — nothing ran
@@ -705,12 +800,12 @@ 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);
+        await giveUp(client, row.run_id, reason, processToken);
         throw new Error(`NO AGENT IS RUNNING: ${reason}`);
     }
     out(`dispatch run ${row.run_id}  level ${level}  under ${parentRunId}  pid ${started.pid}`);
     try {
-        await recordProcess(client, row.run_id, started.pid);
+        await recordProcess(client, row.run_id, started.pid, undefined, processToken);
     }
     catch (error) {
         // Said, not fatal, exactly as at level 1: the agent is running and killing
@@ -719,7 +814,9 @@ async function startChild(client, tools, machineId, parentRunId, brief, codebase
     }
     return {
         runId: row.run_id,
-        settled: settle(client, tools, machineId, level, row.run_id, row.run_card_id, started),
+        settled: settle(client, tools, machineId, level, row.run_id, row.run_card_id, started, true, processToken, isOwner && processToken
+            ? ownerSessionLifecycle(started, row.run_id, harness(), processToken)
+            : undefined),
     };
 }
 /**
@@ -763,11 +860,13 @@ async function attemptsSoFar(client, runId) {
  * ends through `panel3_end_run`, which hands no turns back, and the card says
  * failed.
  *
- * ═══ AND THE FORK LIVES HERE AND NOWHERE ELSE. ═══ FIVE places end a run this
- * way: the settle, and the two failures after the claim in each of `resumeRun`
- * and `startRearmed`. A copy of this rule in each is five places for it to
- * drift, and it drifted the first time it could: those two functions hold the
- * same pair of endings and only one pair was looked at.
+ * ═══ AND THE FORK LIVES HERE AND NOWHERE ELSE. ═══ SIX places end a run this
+ * way: the settle, the two failures after the claim in each of `resumeRun` and
+ * `startRearmed`, and the pre-spawn failure in `answerCard`. A copy of this rule
+ * in each is six places for it to drift, and it drifted the first time it could:
+ * those two functions hold the same pair of endings and only one pair was looked
+ * at. `answerCard`'s was missing outright, which is how a build that could not
+ * read a card's project turned every take into a silent take/recover loop.
  *
  * ALL FIVE CAN SEE LEVEL 1. `resumeRun` serving the retry is what opened its
  * two. `startRearmed`'s were always reachable, because a re-arm has always
@@ -834,7 +933,44 @@ async function endRun(client, level, runId, cardId, why) {
  * cannot end the same way. What `answerCard` always did is what level 1 still
  * does, and the only thing that has moved is where it is written.
  */
-function settle(client, tools, machineId, level, runId, cardId, started, speaksToTheCard = true) {
+function ownerSessionLifecycle(started, ownerId, ownerHarness, processToken, expectedSessionId) {
+    const pending = started.session.then((nativeSessionId) => {
+        if (nativeSessionId === null)
+            return false;
+        if (expectedSessionId && nativeSessionId !== expectedSessionId) {
+            said(`the resumed harness returned a different conversation for owner ${ownerId}; it will not be reused`);
+            return false;
+        }
+        try {
+            writeOwnerSession({
+                ownerId,
+                harness: ownerHarness,
+                nativeSessionId,
+                processToken,
+                state: 'pending',
+            });
+            return true;
+        }
+        catch (error) {
+            said(`could not save the local conversation for owner ${ownerId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    });
+    // Start observing immediately; Codex reports thread.started before its answer.
+    void pending;
+    return {
+        established: async () => {
+            if (await pending)
+                establishOwnerSession(ownerId, processToken);
+        },
+        failed: async () => {
+            // A failed or rejected generation stays pending and therefore cannot be
+            // resumed. Reconciliation is the sole owner of stable-state deletion.
+            await pending;
+        },
+    };
+}
+function settle(client, tools, machineId, level, runId, cardId, started, speaksToTheCard = true, processToken, ownerSession) {
     return started.answered.then(async (answer) => {
         /* ═══ A RUN THAT STOPPED TO ASK DID NOT DIE, WHATEVER THE HARNESS PRINTED
            ON ITS WAY OUT. ═══
@@ -860,11 +996,27 @@ 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 && (await runNow(client, runId)).state === 'asked') {
-            await writeAnswer(client, runId, cardId, null);
-            return;
+        if (!answer.ok) {
+            const run = await runNow(client, runId);
+            if (run.state === 'asked') {
+                const accepted = await writeAnswer(client, runId, cardId, null, processToken);
+                if (accepted)
+                    await ownerSession?.established();
+                else
+                    await ownerSession?.failed();
+                return;
+            }
+            /* Level 1's only successful result is the owner pointer written by
+               dispatch. Its stdout is deliberately hidden, and Codex may therefore
+               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);
+                return;
+            }
         }
         if (!answer.ok) {
+            await ownerSession?.failed();
             /* ═══ A PROCESS THAT STARTED AND THEN DIED BADLY IS STARTED AGAIN. ═══
                recovery-1/ux.md, Slice 3: "the agent's harness fails on something that
                is nobody's fault: a rate limit, a dropped connection, a provider
@@ -904,7 +1056,9 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
             const attempts = await attemptsSoFar(client, runId);
             if (started.pid !== null && attempts < MAX_ATTEMPTS) {
                 out(`retry    run ${runId}  attempt ${attempts} of ${MAX_ATTEMPTS} died: ${answer.reason}`);
-                const again = await resumeRun(client, tools, machineId, runId, started.pid);
+                const again = processToken === undefined
+                    ? await resumeRun(client, tools, machineId, runId, started.pid)
+                    : await activateOwner(client, tools, machineId, runId, processToken, started.pid);
                 if (again)
                     return again.settled;
                 /* ═══ THE CLAIM MATCHED NOTHING, AND THAT IS NOT ALWAYS SOMEBODY ELSE
@@ -937,7 +1091,9 @@ function settle(client, tools, machineId, level, runId, cardId, started, speaksT
                both already read, so the count reaches a person from one place rather
                than two. */
             const why = attempts > 1 ? `${answer.reason} (after ${attempts} attempts)` : answer.reason;
-            const ended = await endRun(client, level, runId, cardId, why);
+            const ended = processToken === undefined
+                ? await endRun(client, level, runId, cardId, why)
+                : (await giveUp(client, runId, why, processToken)) !== null;
             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
@@ -954,7 +1110,11 @@ 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". */
-        await writeAnswer(client, runId, cardId, speaksToTheCard ? answer.text : null);
+        const accepted = await writeAnswer(client, runId, cardId, speaksToTheCard ? answer.text : null, processToken);
+        if (accepted)
+            await ownerSession?.established();
+        else
+            await ownerSession?.failed();
     });
 }
 /**
@@ -1052,9 +1212,7 @@ async function resumeRun(client, tools, machineId, runId, afterPid) {
     }
     else {
         try {
-            cwd = level === 1
-                ? scratchDir()
-                : checkoutForCodebase(await codebaseOfRun(client, runId), hostname());
+            cwd = await workingDirectory(client, runId, level, false);
         }
         catch (error) {
             /* ═══ THE REASON IS WRITTEN TO THE DATABASE, SO IT MAY NOT CARRY A PATH.
@@ -1155,9 +1313,7 @@ async function startRearmed(client, tools, machineId, row) {
     }
     let cwd;
     try {
-        cwd = level === 1
-            ? scratchDir()
-            : checkoutForCodebase(await codebaseOfRun(client, row.run_id), hostname());
+        cwd = await workingDirectory(client, row.run_id, level, false);
     }
     catch (error) {
         /* ═══ THE REASON IS WRITTEN TO THE DATABASE, SO IT MAY NOT CARRY A PATH.
@@ -1180,6 +1336,9 @@ async function startRearmed(client, tools, machineId, row) {
        POSSIBLE. Level 3 has no `dispatch`, so it has no children to have: null
        says that, where an empty list would say it chose to send nobody. */
     const children = level === 3 ? null : await childrenOf(client, row.run_id);
+    const deliveredArtifact = row.ask_id !== null && row.mine
+        ? await rearmedArtifactAnswer(client, row.ask_id)
+        : null;
     /* ═══ THREE REASONS, AND THE ROW SAYS WHICH. ═══ No question is ux.md's third
        re-arm: everybody it sent has finished, and it is started to read them back.
        `children` cannot be null on that path — only a run with children is ever
@@ -1188,7 +1347,7 @@ async function startRearmed(client, tools, machineId, row) {
     const prompt = row.ask_id === null
         ? readBackPrompt(row.run_brief, row.run_report, children ?? [])
         : row.mine
-            ? answerPrompt(row.run_brief, row.run_report, children, row.question ?? '', row.answer ?? '')
+            ? answerPrompt(row.run_brief, row.run_report, children, row.question ?? '', row.answer ?? '', deliveredArtifact)
             : escalationPrompt(row.run_brief, row.run_report, children, row.ask_id, row.question ?? '');
     const started = startAgent(prompt, level, tools.urlFor(row.run_id), cwd);
     if (started.pid === null) {
@@ -1263,6 +1422,312 @@ async function childrenOf(client, runId) {
             : c.report.split('\n').map((l) => `    ${l}`)),
     ]);
 }
+/** Private owner context: enough to continue or stop work, without hierarchy or activity text. */
+async function ownerChildren(client, runId) {
+    const children = await returned(client.from('panel3_runs').select('id, state, report, failed_because')
+        .eq('parent_run_id', runId).order('started_at'), 'read', `what owner ${runId} sent others to do`);
+    return children.map((child) => [
+        `${child.id}  ${child.state}`,
+        ...(child.failed_because ? [`ended: ${child.failed_because}`] : []),
+        child.report ?? 'no report',
+    ].join('\n'));
+}
+async function ownerConversation(client, cardId, leased, initialLeaseRunId) {
+    const [turns, rawAsks] = await Promise.all([
+        returned(client.from('panel3_turns').select('id, role, body, created_at, lease_id')
+            .eq('card_id', cardId).order('created_at'), 'read', `the visible conversation on card ${cardId}`),
+        returned(client.from('panel3_asks').select(`id, created_at, ${ASK_CONTENT_COLUMNS}`)
+            .eq('card_id', cardId).not('decision_id', 'is', null).order('created_at'), 'read', `the visible questions on card ${cardId}`),
+    ]);
+    const asks = await withAskContent(client, rawAsks);
+    const events = [
+        ...turns.map((turn) => ({
+            at: turn.created_at,
+            kind: turn.role,
+            id: turn.id,
+            body: turn.body,
+            needsReply: turn.role === 'user'
+                && (leased.has(turn.id) || turn.lease_id === initialLeaseRunId),
+        })),
+        ...asks.map((ask) => ({
+            at: ask.created_at,
+            kind: 'question',
+            id: ask.id,
+            body: ask.question ?? '(question unavailable)',
+            answer: ask.answer,
+            relatedArtifactId: ask.related_artifact_id,
+            relatedArtifactRevision: ask.related_artifact_revision,
+            artifactAnswer: artifactAnswer(ask.related_artifact_id, ask.related_artifact_revision, ask.selected_options)?.answer ?? null,
+        })),
+    ];
+    return events.sort((a, b) => a.at.localeCompare(b.at) || a.id.localeCompare(b.id));
+}
+/** The first owner gets the same durable context as every later activation. */
+export async function initialOwnerPrompt(client, cardId, launcherRunId, brief) {
+    const events = await ownerConversation(client, cardId, new Set(), launcherRunId);
+    return ownerActivationPrompt(brief, null, events, [], null);
+}
+/** Only facts delivered by this activation enter an already-resumed native
+ * conversation. Older visible turns are already in that conversation. */
+export function ownerContinuationPrompt(brief, report, events, children, delivered) {
+    const messages = events.filter((event) => event.kind === 'user' && event.needsReply);
+    return [
+        'CONTINUE THE CTRL+SPC CONVERSATION YOU ALREADY OWN.',
+        'Use only the new facts below as the new turn. Keep coordinating the whole card and speak as CTRL+SPC.',
+        '',
+        'NEW USER MESSAGES',
+        ...(messages.length === 0
+            ? ['None.']
+            : messages.flatMap((event) => [`Turn ${event.id}`, event.body])),
+        ...(delivered === null ? [] : delivered.mine ? [
+            '',
+            'ANSWER TO YOUR QUESTION',
+            `Question ${delivered.id}: ${delivered.question}`,
+            `Answer: ${delivered.answer ?? '(no answer text)'}`,
+            ...presentedArtifactAnswerContext(delivered.artifactAnswer),
+        ] : [
+            '',
+            'A WORKER NEEDS YOUR DECISION',
+            `Question ${delivered.id}: ${delivered.question}`,
+            'Answer it with answer_escalation if you can. If the person must decide, ask them directly.',
+        ]),
+        '',
+        'CURRENT PRIVATE WORKER SNAPSHOT — THIS REPLACES THE PREVIOUS SNAPSHOT',
+        ...(children.length === 0 ? ['You have sent nobody.'] : children),
+        '',
+        'YOUR CURRENT DURABLE REPORT',
+        report ?? 'Nothing yet.',
+        '',
+        'YOUR IMMUTABLE RESPONSIBILITY',
+        brief,
+    ].join('\n');
+}
+async function ownerCandidate(client, runId) {
+    const candidates = await returned(client.from('panel3_runs')
+        .select('id, card_id, codebase_id, machine_id, harness, state, ended_at, attempts, pid, started_at, resumed_at, process_token, handed_back_at, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id, state)')
+        .eq('id', runId), 'read', `conversation owner ${runId}`);
+    const candidate = candidates[0];
+    return candidate?.card?.conversation_run_id === candidate?.id ? candidate : null;
+}
+async function ownerDirectory(client, candidate) {
+    return workingDirectory(client, candidate.id, 2, true, candidate.codebase_id === null ? null : undefined);
+}
+export function resumableOwnerSessionId(candidate, machineId, machineHarness) {
+    const local = readOwnerSession(candidate.id);
+    return candidate.machine_id === machineId
+        && candidate.harness === machineHarness
+        && local?.state === 'established'
+        && local.harness === machineHarness
+        && local.processToken === candidate.process_token
+        ? local.nativeSessionId
+        : undefined;
+}
+async function activateOwner(client, tools, machineId, runId, afterProcessToken = null, afterPid = null) {
+    const candidate = await ownerCandidate(client, runId);
+    if (!candidate)
+        return null;
+    const machineHarness = harness();
+    const resumeSessionId = resumableOwnerSessionId(candidate, machineId, machineHarness);
+    const cwd = await ownerDirectory(client, candidate);
+    const { data, error } = await client.rpc('panel3_take_owner_activation', {
+        p_run_id: runId,
+        p_machine_id: machineId,
+        p_agent: machineHarness,
+        p_after_process_token: afterProcessToken,
+        p_after_pid: afterPid,
+    });
+    if (error)
+        throw new Error(`could not activate conversation owner ${runId}: ${error.message}`);
+    const claimed = data?.[0];
+    if (!claimed)
+        return null;
+    const [events, children] = await Promise.all([
+        ownerConversation(client, claimed.run_card_id, new Set(claimed.turn_ids ?? [])),
+        ownerChildren(client, runId),
+    ]);
+    const currentArtifactAnswer = deliveredArtifactAnswer(events, claimed);
+    const delivered = claimed.ask_id === null ? null : {
+        id: claimed.ask_id,
+        question: claimed.question ?? '(question unavailable)',
+        answer: claimed.answer,
+        mine: claimed.mine === true,
+        artifactAnswer: currentArtifactAnswer,
+    };
+    const prompt = resumeSessionId
+        ? ownerContinuationPrompt(claimed.run_brief, claimed.run_report, events, children, delivered)
+        : ownerActivationPrompt(claimed.run_brief, claimed.run_report, events, children, delivered !== null && !delivered.mine
+            ? { id: delivered.id, question: delivered.question }
+            : null, currentArtifactAnswer, 
+        /* ═══ A PROCESS OF ITS OWN ENDED BEFORE IT FINISHED. ═══ `afterPid` is the
+           fact, and it is non-null on all three paths that follow one: a harness
+           that crashed, a machine that went down, and now a person's correction.
+           The sentences it adds say what to do and never why, because those three
+           are not the same event and `prompt.ts` exists to stop an agent being
+           told an untrue reason for its own restart. */
+        afterPid !== null);
+    const started = startAgent(prompt, 2, tools.urlFor(runId, claimed.process_token), cwd, { ownerId: runId, ...(resumeSessionId ? { resumeSessionId } : {}) });
+    if (started.pid === null) {
+        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);
+        throw new Error(`NO AGENT IS RUNNING: ${reason}`);
+    }
+    try {
+        await recordProcess(client, runId, started.pid, undefined, claimed.process_token);
+    }
+    catch (error) {
+        said(`${error instanceof Error ? error.message : String(error)} (the run is still going)`);
+    }
+    return {
+        settled: settle(client, tools, machineId, 2, runId, claimed.run_card_id, started, true, claimed.process_token, ownerSessionLifecycle(started, runId, machineHarness, claimed.process_token, resumeSessionId)),
+    };
+}
+/** The only owner rows the normal poll may try, including an explicit hand-back move. */
+export function ownerPollClaim(candidate) {
+    if (candidate.state === 'running') {
+        if (candidate.handed_back_at === null || candidate.process_token === null)
+            return null;
+        return { afterProcessToken: candidate.process_token, afterPid: null };
+    }
+    if (candidate.state === 'finished' || candidate.state === 'asked') {
+        return { afterProcessToken: null, afterPid: null };
+    }
+    return null;
+}
+/**
+ * ═══ THE PROCESS A PERSON'S CORRECTION CANNOT HAVE REACHED. ═══
+ *
+ * redirect-5/ux.md: stop ends work, and changing its direction mid-flight did
+ * not exist. ux.md's mechanism is "redirect is stop plus respawn", and the
+ * respawn half is already built: a process that dies is started again as itself
+ * by `settle`, and the claim it goes through leases every unaddressed person
+ * turn on its way. **So the only thing missing was the ending**, and this is it.
+ *
+ * ═══ IT IS A MIRROR OF THE RETRY CLAIM, AND MUST BE CHANGED WITH IT. ═══
+ * `20260914090000`'s retry branch requires the token, `running`, `ended_at` null,
+ * the pid, and `attempts < 3`. The kill is the ONE irreversible act in this file:
+ * every other predicate here pre-filters an RPC that can refuse harmlessly, and
+ * a claim refused AFTER a kill falls through `settle` to `giveUp`, which turns a
+ * person's correction into a FAILED CARD. So every condition below is either
+ * that mirror, or a product rule with a named cost.
+ *
+ * Two things are NOT here, because neither is a property of the row: whether
+ * this run owns its card, and whether this daemon holds its process. Both are
+ * the caller's, and `mine` is what makes the respawn possible at all.
+ */
+export function redirectedProcess(candidate, machineId, 
+/** The newest unaddressed person turn per card. MAX, never first-seen: a turn
+ *  left unaddressed while a question was open would otherwise pin its card
+ *  below `resumed_at` for good and nothing on it could ever redirect. */
+waiting, cardId, booted) {
+    // The claim's own five, mirrored.
+    if (candidate.state !== 'running' || candidate.ended_at !== null)
+        return null;
+    if (candidate.attempts >= MAX_ATTEMPTS)
+        return null;
+    // The person moved this card to another machine. Killing here makes `settle`
+    // retry locally and the claim clears `handed_back_at`, silently reversing them.
+    if (candidate.handed_back_at !== null)
+        return null;
+    // `mine` is not enough: a takeover moves the row while this daemon still holds
+    // a promise for it, and the claim then refuses on the machine predicate.
+    if (candidate.machine_id !== machineId)
+        return null;
+    /* ═══ A CARD THAT NEEDS THE PERSON IS NOT A CARD THEY ARE REDIRECTING. ═══
+       The claim refuses to lease turns while a person's question is open, so a
+       kill here would destroy the work and NOT deliver the correction. The card's
+       state is written from a character-identical predicate by the
+       `panel3_prepare_user_turn` trigger on every person message, so it is the
+       same fact, one read earlier. */
+    if (candidate.card_state !== 'working')
+        return null;
+    /* ═══ AND IT HAS TO BE A MESSAGE THIS PROCESS CANNOT HAVE SEEN. ═══ The rule
+       `panel3_take_turns` already applies one level up. Measured against the
+       attempt that is running NOW, which is also what stops a replacement being
+       killed by the very message that caused it. */
+    const said = waiting.get(cardId);
+    if (said === undefined)
+        return null;
+    if (new Date(said).getTime() <= new Date(candidate.resumed_at ?? candidate.started_at).getTime()) {
+        return null;
+    }
+    return runProcessIsAlive(candidate, booted) ? candidate.pid : null;
+}
+export function pendingOwnerSessionWithinGrace(candidate, now = Date.now()) {
+    const local = readOwnerSession(candidate.id);
+    return !!local
+        && local.state === 'pending'
+        && local.harness === candidate.harness
+        && local.processToken === candidate.process_token
+        && now - new Date(local.updatedAt).getTime() < OWNER_SESSION_GRACE_MS;
+}
+async function takeOwnerActivations(client, tools, machineId, mine, hold) {
+    /* ═══ THE MESSAGES NOBODY HAS TAKEN, READ BEFORE THE RUNS, DELIBERATELY. ═══
+       A claim landing between these two reads stamps a `resumed_at` NEWER than
+       every turn it just leased, so the redirect below refuses and nothing is
+       killed. In the other order the same claim leaves a stale `resumed_at` beside
+       a turn that now reads unaddressed, and the daemon kills the replacement it
+       has just started. One narrow indexed read (`panel3_turns_takeable_idx`),
+       unconditional because that ordering is the whole point of it. */
+    const outstanding = await returned(client.from('panel3_turns')
+        .select('card_id, created_at')
+        .eq('role', 'user')
+        .is('addressed_at', null), 'read', 'the messages nobody has taken yet');
+    const waiting = new Map();
+    for (const turn of outstanding) {
+        // THE NEWEST PER CARD. See `redirectedProcess`: first-wins would pin a card
+        // below its own `resumed_at` for good.
+        const held = waiting.get(turn.card_id);
+        if (held === undefined || turn.created_at > held)
+            waiting.set(turn.card_id, turn.created_at);
+    }
+    const candidates = await returned(client.from('panel3_runs')
+        .select('id, card_id, codebase_id, machine_id, harness, state, ended_at, attempts, pid, started_at, resumed_at, process_token, handed_back_at, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id, state)')
+        .in('state', ['finished', 'asked', 'running']), 'read', 'conversation owners that may be ready');
+    for (const candidate of candidates) {
+        if (candidate.card?.conversation_run_id !== candidate.id)
+            continue;
+        /* ═══ A RUN THIS DAEMON IS HOLDING IS THE ONLY ONE A CORRECTION CAN
+           REDIRECT. ═══ Not because of the claim, which is not made here at all, but
+           because of what happens AFTER the kill: the respawn is the dying process's
+           own `settle`, and only the daemon that started it has one. Kill anything
+           else and there is a dead process, a row still reading `running` and a card
+           still saying `working`, with nothing local to retry it. */
+        if (mine.has(candidate.id)) {
+            const pid = redirectedProcess({ ...candidate, card_state: candidate.card?.state ?? null }, machineId, waiting, candidate.card_id, bootedAt());
+            if (pid !== null) {
+                killTree({ pid, kill: (signal) => process.kill(pid, signal) });
+                /* ═══ SIGNALLED, NOT KILLED, AND THE WORD IS THE POINT. ═══ `killTree`
+                   swallows a refused signal on both platforms, so saying "killed" would
+                   claim a death this daemon never observed. A process that survives is
+                   still running, still held, and its turn is still unaddressed and still
+                   newer than `resumed_at`, so the next poll signals it again — the same
+                   rule `killStopped` states two hundred lines below. */
+                out(`redirect card ${candidate.card_id}  run ${candidate.id}  signalled pid ${pid}`);
+            }
+            continue;
+        }
+        if (pendingOwnerSessionWithinGrace(candidate))
+            continue;
+        if (candidate.handed_back_at !== null
+            && candidate.machine_id === machineId
+            && (runProcessIsAlive(candidate, bootedAt())
+                || (candidate.pid === null
+                    && Date.now() - new Date(candidate.resumed_at ?? candidate.started_at).getTime() < PID_GRACE_MS)))
+            continue;
+        const claim = ownerPollClaim(candidate);
+        if (!claim)
+            continue;
+        try {
+            const activated = await activateOwner(client, tools, machineId, candidate.id, claim.afterProcessToken, claim.afterPid);
+            if (activated)
+                hold(candidate.id, activated.settled);
+        }
+        catch (error) {
+            said(`could not activate owner ${candidate.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 /**
  * ═══ THE TWO ENDS THE PERSON CAUSES, WHICH ARE THE TWO THIS DAEMON KILLS. ═══
@@ -1300,6 +1765,46 @@ function runProcessIsAlive(run, booted) {
         return false;
     return processIsAlive(run.pid);
 }
+/** Reconcile only CTRL+SPC-owned local session state. Native Claude and Windows
+ * Codex transcripts live in harness-owned locations and are deliberately not
+ * touched here. A current owner row, live PID, in-flight process, or fresh
+ * pid-null claim always defers cleanup. Stable state is removed only after the
+ * owner row disappears, becomes terminal, or no longer owns its card. */
+export async function reconcileOwnerSessions(client, machineId, _machineHarness, inFlightOwnerIds = new Set()) {
+    const mappingIds = listOwnerSessionIds();
+    const homeIds = listPanel3CodexOwnerHomeIds();
+    const all = [...new Set([...mappingIds, ...homeIds])];
+    const invalid = all.filter((id) => !validSessionUuid(id));
+    for (const id of invalid)
+        removePanel3CodexOwnerHome(id);
+    const ids = all.filter(validSessionUuid);
+    if (ids.length === 0)
+        return;
+    const rows = await returned(client.from('panel3_runs')
+        .select('id, machine_id, harness, state, pid, started_at, resumed_at, ended_at, process_token, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)')
+        .in('id', ids), 'read', 'which local conversation sessions still have an owner');
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    for (const id of ids) {
+        if (inFlightOwnerIds.has(id))
+            continue;
+        const row = byId.get(id);
+        const localProcessInUse = !!row
+            && row.machine_id === machineId
+            && ((row.pid !== null && processIsAlive(row.pid))
+                || (row.state === 'running'
+                    && row.ended_at === null
+                    && row.pid === null
+                    && Date.now() - new Date(row.resumed_at ?? row.started_at).getTime() < PID_GRACE_MS));
+        const rowStillOwnsConversation = !!row
+            && row.card?.conversation_run_id === id
+            && ['running', 'asked', 'finished'].includes(row.state);
+        if (localProcessInUse || rowStillOwnsConversation)
+            continue;
+        removeOwnerSession(id);
+        if (homeIds.includes(id))
+            removePanel3CodexOwnerHome(id);
+    }
+}
 /**
  * ═══ THE USER STOPPED IT, OR THEIR NEXT MESSAGE REPLACED IT, SO THE PROCESS
  *     STOPS. ═══
@@ -1441,7 +1946,7 @@ async function killStopped(client, machineId) {
 async function recoverStranded(client, tools, machineId, mine, hold) {
     const live = await returned(client
         .from('panel3_runs')
-        .select('id, card_id, parent_run_id, state, pid, started_at, resumed_at')
+        .select('id, card_id, parent_run_id, state, pid, started_at, resumed_at, process_token, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)')
         .eq('machine_id', machineId)
         /* ═══ AND A RUN THAT STOPPED TO ASK IS SWEPT TOO, WHICH IS WHAT MAKES THE
            RE-ARM'S OWN PREDICATE SAFE. ═══ `panel3_take_rearms` will only start a run
@@ -1468,6 +1973,23 @@ async function recoverStranded(client, tools, machineId, mine, hold) {
             continue;
         if (runProcessIsAlive(run, booted))
             continue;
+        const isOwner = run.card?.conversation_run_id === run.id && run.process_token !== null;
+        if (isOwner) {
+            try {
+                if (run.state === 'asked') {
+                    await writeAnswer(client, run.id, run.card_id, null, run.process_token ?? undefined);
+                }
+                else {
+                    const resumed = await activateOwner(client, tools, machineId, run.id, run.process_token, run.pid);
+                    if (resumed)
+                        hold(run.id, resumed.settled);
+                }
+            }
+            catch (error) {
+                said(`could not recover owner ${run.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            continue;
+        }
         if (run.state === 'asked') {
             /* ═══ ITS END IS STAMPED AND ITS TURNS ARE LEFT ALONE. ═══ This run is not
                handed back and is not started again from here: its continuation is the
@@ -1662,7 +2184,7 @@ export async function takeHandedBack(client, tools, machineId, mine, hold) {
        whether its pid means anything here. See the header. */
     const offered = await returned(client
         .from('panel3_runs')
-        .select('id, card_id, machine_id, pid, started_at, resumed_at')
+        .select('id, card_id, machine_id, pid, started_at, resumed_at, process_token, card:panel3_cards!panel3_runs_card_id_fkey(conversation_run_id)')
         .not('handed_back_at', 'is', null)
         /* WHAT THE OFFER MEANS, RESTATED IN THE READ. `panel3_hand_back` only ever
            stamps a dispatched run that is still going, and `panel3_resume` refuses
@@ -1708,7 +2230,9 @@ export async function takeHandedBack(client, tools, machineId, mine, hold) {
             continue;
         }
         try {
-            const resumed = await resumeRun(client, tools, machineId, run.id, null);
+            const resumed = run.card?.conversation_run_id === run.id && run.process_token !== null
+                ? await activateOwner(client, tools, machineId, run.id, run.process_token, null)
+                : await resumeRun(client, tools, machineId, run.id, null);
             if (resumed)
                 hold(run.id, resumed.settled);
             else
@@ -1794,8 +2318,8 @@ export async function run(args, injected) {
        `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. */
-    const tools = await startToolsServer(client, async (parentRunId, brief, codebase) => {
-        const child = await startChild(client, tools, machineId, parentRunId, brief, codebase);
+    const tools = await startToolsServer(client, async (parentRunId, brief, codebase, processToken) => {
+        const child = await startChild(client, tools, machineId, parentRunId, brief, codebase, processToken);
         hold(child.runId, child.settled);
         return { runId: child.runId };
     });
@@ -1856,6 +2380,7 @@ export async function run(args, injected) {
                to run first: `panel3_stop_card` has already ended the runs, so recovery
                cannot see them and neither take can start them. */
             await killStopped(client, machineId);
+            await reconcileOwnerSessions(client, machineId, machineHarness, new Set(inFlight.keys()));
             await recoverStranded(client, tools, machineId, new Set(inFlight.keys()), hold);
             /* ═══ AND THEN WHAT SOMEBODY ELSE'S MACHINE WAS HOLDING, IF A PERSON HANDED
                IT BACK. ═══ AFTER the sweep, deliberately: this machine settles its own
@@ -1868,6 +2393,9 @@ export async function run(args, injected) {
                with a brief and a report behind it, comes before work that has not
                started. */
             await takeHandedBack(client, tools, machineId, new Set(inFlight.keys()), hold);
+            /* Every reason a conversational owner may continue is claimed together.
+               The legacy turn and re-arm takes exclude named owners in the database. */
+            await takeOwnerActivations(client, tools, machineId, new Set(inFlight.keys()), hold);
             /* 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. */