flowviant 0.125.7 → 0.125.9

package/bin/lib/workAgentPlans.mjs

@@ -1,4 +1,7 @@
+import { planWork, reportPlanOutcome } from './workActivity.mjs';
 /** Agent plan claims, read-only planning turns, and proposal reports. */
+import { PLAN_RECOVERY_SYSTEM, parsePlanDiagnosis, watchPlanAttempt } from './workPlanRecovery.mjs';
+import { readClaudeAuthStatus } from './runtimeAuth.mjs';
 import { discoveryGuide } from './discoveryContract.mjs';
 import { compareRepositoryBaselines, measureRepositoryBaseline, repositoryBaselineOf } from './repositoryBaseline.mjs';
 import { knowledgeDirFor } from './knowledgeFiles.mjs';
@@ -33,10 +36,12 @@ export function createWorkAgentPlans({
   runTurn = defaultRunTurn,
   pickRuntimeFor = defaultPickRuntimeFor,
   detectRuntimes = defaultDetectRuntimes,
+  authStatus = readClaudeAuthStatus,
 }) {
   const AGENT_PLAN_DONE_URL = fleetEndpoint('agent-plan-done', FLEET_URL);
   const AGENT_PLAN_ACTIVITY_URL = fleetEndpoint('agent-plan-activity', FLEET_URL);
   const AGENT_PLAN_CLAIM_URL = fleetEndpoint('agent-plan-claim', FLEET_URL);
+  const AGENT_PLAN_STATE_URL = fleetEndpoint('agent-plan-state', FLEET_URL);
 
   // ── AGENT PLAN JOBS: the Deploy press ──────────────────────────────────────
   //
@@ -60,13 +65,13 @@ export function createWorkAgentPlans({
   // tabs. It writes nothing, so a writer lock would only starve real work.
   const planning = new Set(); // press ids in flight on this tick
 
-  const postAgentPlan = async (body) => {
+  const sendAgentPlan = async (body) => {
     // Bounded retry on 408/429/5xx, an other-4xx counted as delivered — see
     // postBestEffort's own docblock. Previously this swallowed every
     // response including ordinary 5xx and rate limits, so a transient
     // failure looked identical to a hostile refusal: nothing retried, and
     // the proposal sat unsettled until the server's own expiry.
-    await postBestEffort(AGENT_PLAN_DONE_URL, { ...body, instance: DAEMON_INSTANCE });
+    return postBestEffort(AGENT_PLAN_DONE_URL, { ...body, instance: DAEMON_INSTANCE });
   };
 
   /**
@@ -90,7 +95,7 @@ export function createWorkAgentPlans({
    * turn it describes. A daemon that never calls this is a machine that has
    * not narrated, which is the only thing an absent line can mean.
    */
-  const postAgentPlanActivity = async (planId, line) => {
+  const postAgentPlanActivity = async (planId, line, attempt, phase, diagnosis) => {
     const text = envScrub(String(line ?? '')).slice(0, 400);
     if (!text) return;
     try {
@@ -98,7 +103,7 @@ export function createWorkAgentPlans({
         method: 'POST',
         headers: fleetHeaders(),
         signal: AbortSignal.timeout(15_000),
-        body: JSON.stringify({ planId, line: text }),
+        body: JSON.stringify({ planId, line: text, instance: DAEMON_INSTANCE, ...(attempt !== undefined ? { attempt } : {}), ...(phase ? { phase, diagnosis } : {}) }),
       });
     } catch {
       /* a readout — losing a line costs nothing */
@@ -134,7 +139,7 @@ export function createWorkAgentPlans({
   const PLAN_TURN_TIMEOUT_MS = 15 * 60_000;
 
   // The peer may hold it; doing nothing is the safe answer.
-  const claimAgentPlan = (id) => claimFleetLease(AGENT_PLAN_CLAIM_URL, { id });
+  const claimAgentPlan = (id, attempt) => claimFleetLease(AGENT_PLAN_CLAIM_URL, { id, ...(attempt !== undefined ? { attempt } : {}) });
 
   /** See `runAgentTurn` — the admission reservation, released the moment the
    *  planner's CLI exists. */
@@ -149,11 +154,27 @@ export function createWorkAgentPlans({
     // kill keeps (refuse cheaply, then claim) and it is because these two
     // lanes settle differently: a kill's settle does not check a lease for the
     // not-found case, and a plan's always does.
-    if (!(await claimAgentPlan(id))) return;
+    if (!(await claimAgentPlan(id, job.attempt))) return;
+    const control = job.recoveryEnabled ? await watchPlanAttempt(AGENT_PLAN_STATE_URL, job) : null;
+    const report = async (body) => {
+      const result = { ...body, ...(job.attempt !== undefined ? { attempt: job.attempt } : {}) };
+      reportPlanOutcome(job, result);
+      // Keep the measured result while its acknowledgement is unknown. A
+      // network retry delivers this report, never another paid planning turn.
+      while (!control?.signal.aborted) {
+        const sent = await sendAgentPlan(result);
+        if (sent !== false || !job.recoveryEnabled) return;
+        await postAgentPlanActivity(id, 'The Plan result has not been acknowledged. Retrying delivery.', job.attempt);
+        await new Promise(resolve => setTimeout(resolve, 3000));
+      }
+    };
+    const unavailable = (reason) => report({ id, ...(job.recoveryEnabled ? { question: { question: `${reason}. Can you make that CLI available on the machine and tell me when it is ready?`, context: reason } } : { error: reason }) });
+    try {
+    if (control?.signal.aborted) return;
     if (tasks.length === 0) {
       // The press named cards the doc no longer has. A real answer, and one the
       // board can explain, rather than a turn that plans nothing.
-      await postAgentPlan({ id, error: 'those cards are no longer on the board' });
+      await report({ id, error: 'those cards are no longer on the board' });
       return;
     }
 
@@ -172,23 +193,27 @@ export function createWorkAgentPlans({
       rt = pickedRuntime;
       const runtime = runtimeById(rt);
       if (!runtime) {
-        await postAgentPlan({ id, error: `${rt} is not a CLI this machine knows` });
+        await unavailable(`${rt} is not a CLI this machine knows`);
         return;
       }
       const label = runtime.label;
       if (!detectRuntimes().find((r) => r.id === rt)?.installed) {
-        await postAgentPlan({ id, error: `${label} is not installed on this machine` });
+        await unavailable(`${label} is not installed on this machine`);
         return;
       }
       if (!canRun(runtime, 'consult')) {
-        await postAgentPlan({ id, error: `${label} can't run a read-only turn on this machine` });
+        await unavailable(`${label} can't run a read-only turn on this machine`);
         return;
       }
     } else {
       rt = pickRuntimeFor('consult');
     }
     if (!rt) {
-      await postAgentPlan({ id, error: 'no CLI on this machine can run a read-only turn' });
+      await unavailable('No CLI on this machine can run a read-only turn');
+      return;
+    }
+    if (job.recoveryEnabled && job.recovery && rt === 'claude' && authStatus({ refresh: true }).signedIn === false) {
+      await report({ id, question: { question: 'Claude Code reports that it is signed out. Can you sign in on this machine and tell me when it is ready?', context: 'The CLI’s native auth status reported signed out.' } });
       return;
     }
 
@@ -204,7 +229,7 @@ export function createWorkAgentPlans({
       const now = Date.now();
       if (now - lastPlanBeat < 2_000) return;
       lastPlanBeat = now;
-      void postAgentPlanActivity(id, line);
+      void postAgentPlanActivity(id, line, job.attempt);
     };
     /**
      * THE MACHINE'S OWN VOICE, for the moments only this side can see — the
@@ -219,10 +244,11 @@ export function createWorkAgentPlans({
      */
     const say = (line) => {
       lastPlanBeat = Date.now();
-      void postAgentPlanActivity(id, line);
+      void postAgentPlanActivity(id, line, job.attempt);
     };
 
     let out = '';
+    let diagnosis = null;
     /** The cap fired: the CLI was still running when this machine stopped it. */
     let wedged = false;
     /**
@@ -234,7 +260,7 @@ export function createWorkAgentPlans({
      */
     let usage = null;
     const discovery = createToolLog(repoRoot);
-    const spent = () => ({ ...(usage ? { usage } : {}), tools: discovery.toolLog });
+    const spent = () => ({ ...(usage ? { usage } : {}), tools: discovery.toolLog, ...(diagnosis ? { diagnosis: diagnosis.summary } : {}) });
     // Said BEFORE the lock is asked for, because a reader only waits when a
     // writer holds the checkout or is queued ahead of it — which is exactly
     // this condition, read one line before we join the queue.
@@ -261,20 +287,17 @@ export function createWorkAgentPlans({
         discovery.toolLog.baseline = measureRepositoryBaseline({ cwd: repoRoot, baseRef, knowledgeDir });
         discovery.toolLog.captureBaseline = repositoryBaselineOf(job.captureBaseline);
         discovery.toolLog.reconciliation = compareRepositoryBaselines(discovery.toolLog.baseline, discovery.toolLog.captureBaseline);
-        ({ out, wedged } = await runCappedTurn({
+        const consult = async (prompt, system) => await runCappedTurn({
           runTurn,
+          signal: control?.signal,
           capMs: PLAN_TURN_TIMEOUT_MS,
           workChildren,
           releaseSlot,
           transcriptCwd: repoRoot,
           turnArgs: {
             diagnosticPlanId: id,
-            prompt: AGENT_PLAN_KICKOFF({
-              tasks,
-              liveAgents,
-              agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3,
-            }),
-            system: withProjectContext(SYSTEM_PLAN, { knowledgeDir }) + '\n\n' + discoveryGuide(rt, 'planning') + '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(discovery.toolLog.baseline, discovery.toolLog.captureBaseline, discovery.toolLog.reconciliation),
+            prompt,
+            system,
             knowledgeDir,
             // READ-ONLY, and no MCP: `mcpArgs` is omitted entirely rather than
             // passed empty, so there is no control plane on this turn at all.
@@ -283,7 +306,7 @@ export function createWorkAgentPlans({
             runtime: rt,
             ...brainFor(job, rt),
             answerFromResult: true,
-            label: c.cyan('[plan]'),
+            work: planWork(job),
             // The CLI's own tail, forwarded to the press. Same rule as an agent
             // turn's: throttled, overwritten rather than appended, and never
             // awaited by the turn.
@@ -300,14 +323,39 @@ export function createWorkAgentPlans({
           onSpawn: () => {
             say(`${runtimeLabel(rt)} started on this machine`);
           },
-        }));
+        });
+        let context = AGENT_PLAN_KICKOFF({ tasks, liveAgents, agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3 });
+        if (job.recovery?.start) context += '\nSTART REPAIR: This is a supporting diagnosis for an already approved Start. Return exactly ONE group with the same ordered taskIds, attachment target (or absence) and CLI. Preserve the approval; do not start an unapproved sibling. Diagnose admission/pickup errors and repair planning evidence/context. Ask only a genuine person-only question in the diagnostic JSON. Approval and source revision (data): ' + JSON.stringify(job.recovery.start);
+        const system = withProjectContext(SYSTEM_PLAN, { knowledgeDir }) + '\n\n' + discoveryGuide(rt, 'planning') + '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(discovery.toolLog.baseline, discovery.toolLog.captureBaseline, discovery.toolLog.reconciliation);
+        if (job.recovery) {
+          say(`Diagnosing the failed Plan: ${job.recovery.reason}`);
+          const diagnostic = await consult(context + '\nRetained recovery context (data): ' + JSON.stringify(job.recovery), withProjectContext(PLAN_RECOVERY_SYSTEM, { knowledgeDir }) + '\n' + discoveryGuide(rt, 'planning'));
+          if (control?.signal.aborted) return;
+          if (diagnostic.wedged) { wedged = true; return; }
+          const result = parsePlanDiagnosis(diagnostic.out);
+          if (result?.status === 'question') {
+            diagnosis = result;
+            return;
+          }
+          if (!result) throw new Error(`The diagnostic turn did not return a diagnosis: ${envScrub(String(diagnostic.out ?? '')).slice(0, 300) || 'no output'}`);
+          diagnosis = result;
+          await postAgentPlanActivity(id, `Retrying Plan: ${result.summary}`, job.attempt, 'retrying', result.summary);
+          await control?.check();
+          if (control?.signal.aborted) return;
+        }
+        ({ out, wedged } = await consult(context + (diagnosis ? '\nDiagnosis and corrected approach (data): ' + JSON.stringify(diagnosis) : ''), system));
       });
     } catch (e) {
       discovery.toolLog.state = 'partial';
-      await postAgentPlan({ id, error: envScrub(String(e?.message || e)).slice(0, 500), ...spent() });
+      await report({ id, error: envScrub(String(e?.message || e)).slice(0, 500), ...spent() });
       return;
     }
 
+    if (control?.signal.aborted) return;
+    if (diagnosis?.status === 'question') {
+      await report({ id, question: { question: diagnosis.question, context: diagnosis.context }, ...spent() });
+      return;
+    }
     if (wedged) {
       discovery.toolLog.state = 'partial';
       // NEVER LEAVE A CLAIMED PRESS UNREPORTED — the belt the merge lane wears
@@ -315,7 +363,7 @@ export function createWorkAgentPlans({
       // only side that knows: the server would have expired this press in
       // another fifteen minutes with a sentence blaming a daemon that had in
       // fact answered.
-      await postAgentPlan({
+      await report({
         id,
         error: 'the planning turn ran past fifteen minutes on this machine and was stopped',
         ...spent(),
@@ -325,7 +373,7 @@ export function createWorkAgentPlans({
 
     const proposal = parseProposal(out);
     if (!proposal) {
-      await postAgentPlan({
+      await report({
         id,
         // The CLI's own words when it has any — a turn that explained why it
         // could not plan is far more use than "planning failed".
@@ -336,7 +384,8 @@ export function createWorkAgentPlans({
       });
       return;
     }
-    await postAgentPlan({ id, proposal, sessionRef: repoRoot, ...spent() });
+    await report({ id, proposal, sessionRef: repoRoot, ...spent() });
+    } finally { control?.stop(); }
   };
 
   const processAgentPlanJobs = (jobs) => {

package/bin/lib/workAgentPrecheck.mjs

@@ -239,7 +239,7 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
           // agent grading its own homework out of its own context; this is a
           // stranger reading a diff.
           answerFromResult: true,
-          label: c.cyan('[pre-review]'),
+          work: { kind: 'pre-review', id: agentId, name: agentName },
           // The CLI's own count for this reading. Set, never accumulated: one
           // turn is one `result` event, and the adding-up is the server's.
           // Tagged with the CLI, so a Claude pre-review of a Codex agent is

package/bin/lib/workAgentTurnExecution.mjs

@@ -1,3 +1,6 @@
+import { agentWork } from './workActivity.mjs';
+import { relayedText } from './prWorkflow.mjs';
+import { measuredMergeResolution } from './agentMergeResolution.mjs';
 import { finishRepositoryDelivery, allResolutionsCommitted } from './repositoryDelivery.mjs';
 /**
  * ONE AGENT TURN, RUN: the worktree, the CLI, and what it left behind.
@@ -18,7 +21,7 @@ import { finishRepositoryDelivery, allResolutionsCommitted } from './repositoryD
  * answered. `measured` is the same bargain the other way: the branch facts and
  * the spend, written here as they are learned, read by that catch.
  */
-import { PROJECT_ID } from './config.mjs';
+import { MODEL, PROJECT_ID } from './config.mjs';
 import { setRuntimeLimit } from './daemonState.mjs';
 import { gitOrNull } from './git.mjs';
 import { turnCommits } from './turnReceipts.mjs';
@@ -49,6 +52,8 @@ import { createDeliveryReporter } from './workDelivery.mjs';
 import { createLiveMessages } from './workLiveMessages.mjs';
 import { createOrchestrator } from './orchestrator.mjs';
 import { claudeOrchestrationSafe } from './orchestratorHooks.mjs';
+import { ORCHESTRATED_POSTURES, orchestratesPosture } from './orchestratorPrompt.mjs';
+import { knownCodexModels } from './runtimeOfferings.mjs';
 import { codexSubagentsSafe } from './runtimeCodex.mjs';
 import { measuredRuntimeVersion } from './runtimeDetection.mjs';
 
@@ -304,10 +309,12 @@ export function createAgentTurnExecution({
     }
 
     // ORCHESTRATED ONLY WHERE THE CLI CAN BE GATED (2026-10-17). v2 reaches every
-    // job at the floor; a fenced card or a CLI below its measured floor (unknown
-    // included) has no controller, so no marker: its notes fold on receipt.
+    // job at its kind's floor; an artifact card (design, model, image, deck) or
+    // a CLI below its measured floor (unknown included) has no controller, so
+    // no marker: its notes fold on receipt. Research is orchestrated too since
+    // 2026-10-19, with read-only children (orchestratorPrompt.mjs).
     const codexVersion = rt === 'codex' ? measuredRuntimeVersion('codex')?.version : undefined;
-    const orchestrating = job.orchestrationVersion === 2 && posture === 'build' &&
+    const orchestrating = job.orchestrationVersion === 2 && orchestratesPosture(posture) &&
       (rt === 'claude' ? claudeOrchestrationSafe(measuredRuntimeVersion('claude')?.version) : rt === 'codex' && codexSubagentsSafe(codexVersion));
     /**
      * THE WHOLE STREAM, not just its latest line — see trace.mjs.
@@ -351,6 +358,10 @@ export function createAgentTurnExecution({
      * neither key.
      */
     const brain = brainFor(job, rt);
+    // The card's model and effort as the parent runs them, for an orchestrated
+    // run's children and contract: Claude always names --model (the daemon's
+    // pin when the card has none); Codex's unpinned default is its own.
+    const cardBrain = { model: brain.model ?? (rt === 'claude' ? MODEL : null), effort: brain.effort ?? null };
 
     let out = '';
     let child = null;
@@ -384,7 +395,7 @@ export function createAgentTurnExecution({
     /** THE MODEL THE TURN RAN ON, as its CLI named it (turnModel.mjs) — rides
      *  every settle `usage` rides, for the same reason; null sends no key. */
     let model = null;
-    const brief = makeBrief?.({ agentId, turnId, runtime: rt, model: () => model ?? job.model });
+    const brief = makeBrief?.({ agentId, turnId, workName: job.task?.title || job.agentName, runtime: rt, model: () => model ?? job.model });
     brief?.append('prompt', job.task ? { title: job.task.title, message: job.body, discussion: job.cardThread, brief: job.task.brief, criteria: job.task.criteria } : job.body);
     /**
      * THE AGENT'S LAST MESSAGE, ALONE — where the final JSON object lives.
@@ -404,6 +415,9 @@ export function createAgentTurnExecution({
     try {
       if (orchestrating) {
         orchestrator = await createOrchestrator({ turnId, runtime: rt, trace, admit,
+          // Codex's spawn takes only a catalog model (knownCodexModels, the
+          // measured models_cache.json rows the roster already reports).
+          children: { access: ORCHESTRATED_POSTURES[posture], ...cardBrain, ...(rt === 'codex' ? { catalog: knownCodexModels() } : {}) },
           // Whether the words reached the CLI; Codex reads its inbox from hooks.
           notify: message => liveInput ? run.live?.inject(message) === true : false,
           taken: id => run.live?.onTaken(id) });
@@ -424,8 +438,10 @@ export function createAgentTurnExecution({
         })) } : {}),
         // The kickoff and the system prompt, composed by the agent lane's
         // shape (workAgentTurnShape.mjs) from what this run measured.
+        researchHandoff: job.researchHandoff,
+        researchIdentity: { projectId: PROJECT_ID, agentId, turnId, taskId: job.task?.id ?? job.repositoryTaskId },
         prompt: agentKickoff(job, { cardFiles: files.card, messageFiles: files.message }),
-        system: agentTurnSystem({ taskKind, runtimeLabel: runtimeById(rt)?.label, prerequisitesAccepted: job.prerequisitesAccepted === true, knowledgeDir: knowledgeDirFor(repoRoot), artifactsAccepted: getArtifactsAccepted(), toolsNote, artifactInstructions, toolInstructions: projectTools.instructions, repositoryRun, orchestrated: Boolean(orchestrator) }),
+        system: agentTurnSystem({ taskKind, runtimeLabel: runtimeById(rt)?.label, prerequisitesAccepted: job.prerequisitesAccepted === true, knowledgeDir: knowledgeDirFor(repoRoot), artifactsAccepted: getArtifactsAccepted(), toolsNote, artifactInstructions, toolInstructions: projectTools.instructions, repositoryRun, orchestration: orchestrator ? { posture, runtime: rt, ...cardBrain } : null }),
         agentTools: projectTools,
         writableDirs: repositoryRun?.writableDirs,
         ...((tools.envNeeded || repositoryRun?.tool || orchestrator) ? { mcpEnv: { ...tools.env, ...(repositoryRun?.tool?.env ?? {}), ...(orchestrator?.env ?? {}) } } : {}),
@@ -465,7 +481,7 @@ export function createAgentTurnExecution({
         // Present only when the container named one — see brainFor.
         ...brain,
         answerFromResult: true,
-        label: c.cyan('[agent]'),
+        work: agentWork(job),
         // The CLI's own context measure while the turn runs (claudeInput.mjs),
         // the latest one at a time; the server clears it at turn end.
         onContext: (() => {
@@ -752,7 +768,25 @@ export function createAgentTurnExecution({
       // reported as `nothing` — it did not deliver and it did not ask.
       await postAgentParked(limit, rt);
     }
-    if (job.kind === 'merge_resolve' && repositoryRun) body.mergeResolved = allResolutionsCommitted(repositoryRun.sourcesNow());
+    if (job.kind === 'merge_resolve') {
+      const resolution = () => repositoryRun
+        ? allResolutionsCommitted(repositoryRun.sourcesNow())
+        : measuredMergeResolution(wt, before, baseRef());
+      body.mergeResolved = resolution();
+      if (body.outcome === 'delivered' && body.mergeResolved) {
+        const rows = repositoryRun?.sourcesNow() ?? [{ wt }];
+        for (const r of rows) {
+          const head = gitOrNull(['rev-parse', 'HEAD'], r.wt);
+          const check = await runReviewEntry(agentId, r.wt, job.agentName, repositoryRun ? r : undefined);
+          if (check?.status === 'failed') {
+            body.mergeResolved = false;
+            body.mergeDetail = relayedText(check.text || check.output || 'The repository check failed during merge recovery.').slice(0, 2000);
+          }
+          if (!head || head !== gitOrNull(['rev-parse', 'HEAD'], r.wt)) body.mergeResolved = false;
+        }
+        body.mergeResolved = body.mergeResolved && resolution();
+      }
+    }
     const reply = await postAgentTurn(body);
     // The queue just emptied. Run the project's own check and the AI
     // pre-review HERE, in the worktree we are already standing in and still

package/bin/lib/workAgentTurnReports.mjs

@@ -14,11 +14,13 @@
  * Daemon→server reports, every one of them: no version floor, and a permanent
  * 4xx is the server saying it will never take the body (see each POST).
  */
+import { join } from 'node:path';
+import { createReportJournal } from './reportJournal.mjs';
 import { FLEET_URL } from './config.mjs';
 import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
 import { fleetHeaders, postFleetJson } from './fleetPost.mjs';
 
-export function createAgentTurnReports({ REJECT_RETRY_MS }) {
+export function createAgentTurnReports({ REJECT_RETRY_MS, baseDir = null }) {
   const AGENT_TURN_DONE_URL = fleetEndpoint('agent-turn-done', FLEET_URL);
   const AGENT_TRACE_URL = fleetEndpoint('agent-trace', FLEET_URL);
   const AGENT_ACTIVITY_URL = fleetEndpoint('agent-activity', FLEET_URL);
@@ -40,8 +42,17 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
    * BOUNDED by the roster itself: a held body's clock is refreshed while the
    * server keeps offering its turn, and once offering stops — settled by the
    * re-POST, or expired server-side — the grace below is all that keeps it.
+   *
+   * EVERY HELD BODY IS JOURNALED (2026-10-20), not only a merge recovery's.
+   * Any agent turn whose body was held in memory alone lost it to a restart
+   * between the answer and the server's 200, and the server's re-offer to the
+   * successor ran the turn again. The settle is bound to the machine
+   * credential, not the process, so the successor's re-POST lands it.
    */
-  const agentReported = new Map(); // turnId -> { body, at }
+  const journal = baseDir ? createReportJournal(join(baseDir, 'agent-recovery-reports')) : null;
+  const agentReported = new Map((journal?.load().work ?? []).filter(([id, held]) =>
+    held?.body?.turnId === id && typeof held.at === 'number'));
+  const persistRecovery = () => journal?.save(new Map(agentReported), new Map()); // turnId -> { body, at }
   const agentRejectedUntil = new Map(); // turnId -> earliest re-POST of a refused body
   const AGENT_REPORT_GRACE_MS = 30 * 60_000;
 
@@ -53,6 +64,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
   const postAgentTurn = async (body) => {
     const turnId = String(body.turnId);
     agentReported.set(turnId, { body, at: Date.now() });
+    persistRecovery();
     try {
       const res = await postFleetJson(AGENT_TURN_DONE_URL, body, { timeoutMs: 30_000 });
       const j = await res.json().catch(() => null);
@@ -68,9 +80,10 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
        * class. So a refused body stays HELD — it is the skip-guard — and its
        * re-POST backs off instead of hammering a body the server just refused.
        */
-      if (res.ok) {
+      if (res.ok && (body.mergeResolved === undefined || typeof j?.data?.settled === 'boolean')) {
         agentReported.delete(turnId);
         agentRejectedUntil.delete(turnId);
+        persistRecovery();
       } else if (isConsideredRefusal(res.status)) {
         agentRejectedUntil.set(turnId, Date.now() + REJECT_RETRY_MS);
       }
@@ -160,6 +173,7 @@ export function createAgentTurnReports({ REJECT_RETRY_MS }) {
       else if (now - held.at > AGENT_REPORT_GRACE_MS) {
         agentReported.delete(id);
         agentRejectedUntil.delete(id);
+        persistRecovery();
       }
     }
   };

package/bin/lib/workAgentTurnShape.mjs

@@ -24,7 +24,7 @@
  */
 import { AGENT_TASK_KICKOFF, AGENT_HUMAN_KICKOFF, SYSTEM_AGENT_FOR, withProjectContext } from './prompts.mjs';
 import { INTERNAL_WAIT_CONTRACT } from './agentInternalWait.mjs';
-import { ORCHESTRATOR_CONTRACT } from './orchestratorPrompt.mjs';
+import { orchestratorContract } from './orchestratorPrompt.mjs';
 
 /** What every kickoff of this job is handed: the agent, the card and its
  *  discussion, the job's context handoffs, the card's files, the place in
@@ -74,8 +74,10 @@ export const agentFollowupKickoff = (job, followup, { cardFiles, messageFiles, o
     messageFiles,
   });
 
-/** The turn's system prompt, in its fixed section order. */
-export function agentTurnSystem({ taskKind, runtimeLabel, prerequisitesAccepted, knowledgeDir, artifactsAccepted, toolsNote, artifactInstructions, toolInstructions, repositoryRun, orchestrated }) {
+/** The turn's system prompt, in its fixed section order. `orchestration` is
+ *  null on a solo run, else what the contract names: `{ posture, runtime,
+ *  model, effort }` (orchestratorPrompt.mjs). */
+export function agentTurnSystem({ taskKind, runtimeLabel, prerequisitesAccepted, knowledgeDir, artifactsAccepted, toolsNote, artifactInstructions, toolInstructions, repositoryRun, orchestration = null }) {
   // The knowledge paragraph, when this box holds a library — the same
   // composer the tabs use, so an agent and a tab can never be told two
   // different things about the same directory.
@@ -86,5 +88,5 @@ export function agentTurnSystem({ taskKind, runtimeLabel, prerequisitesAccepted,
     // ARTIFACTS (0.94.0), while the server can show one — an agent's
     // land on its page, under the facts row.
     artifacts: artifactsAccepted,
-  }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (toolInstructions ? `\n\n${toolInstructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : '') + (orchestrated ? `\n\n${ORCHESTRATOR_CONTRACT}` : '');
+  }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (toolInstructions ? `\n\n${toolInstructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : '') + (orchestration ? `\n\n${orchestratorContract(orchestration)}` : '');
 }

package/bin/lib/workAgentTurns.mjs

@@ -1,3 +1,4 @@
+import { reportAgentOutcome } from './workActivity.mjs';
 /**
  * THE AGENT-TURN LANE: which offered turns run on this machine, and that each
  * one is settled exactly once.
@@ -69,7 +70,7 @@ export function createWorkAgentTurns({
     pruneHeldReports,
     agentReported,
     agentRejectedUntil,
-  } = createAgentTurnReports({ REJECT_RETRY_MS });
+  } = createAgentTurnReports({ REJECT_RETRY_MS, baseDir });
 
   // ── AGENT TURNS: one task per prompt ───────────────────────────────────────
   //
@@ -205,7 +206,8 @@ export function createWorkAgentTurns({
     };
     const settleOnce = (body) => {
       settled = true;
-      return postAgentTurn(withLiveReceipts(body));
+      reportAgentOutcome(job, body);
+      return postAgentTurn(withLiveReceipts(job.kind === 'merge_resolve' ? { ...body, mergeResolved: body.mergeResolved ?? false } : body));
     };
 
     // A WRITER on the agent's own place — see the lane header. Only `a-<id>`
@@ -221,11 +223,11 @@ export function createWorkAgentTurns({
         if (settled) return;
         const commits = turnCommits({ repositoryReceipts: measured.repositoryReceipts, wt: measured.wt, before: measured.before, baseRef });
         if (run.interrupted) {
-          await postAgentTurn(withLiveReceipts(interruptedTurnSettlement({ turnId, ran: measured.ranCli === true, commits, usage: measured.usage, model: measured.model, branch: measured.branch, wt: measured.wt })));
+          await settleOnce(interruptedTurnSettlement({ turnId, ran: measured.ranCli === true, commits, usage: measured.usage, model: measured.model, branch: measured.branch, wt: measured.wt }));
           return;
         }
-        await postAgentTurn(
-          withLiveReceipts(failedTurnSettlement({
+        await settleOnce(
+          failedTurnSettlement({
             turnId,
             error,
             commits,
@@ -233,7 +235,7 @@ export function createWorkAgentTurns({
             model: measured.model,
             branch: measured.branch,
             wt: measured.wt,
-          }))
+          })
         );
       }
     }, () => {

package/bin/lib/workIntake.mjs

@@ -1,3 +1,4 @@
+import { reportWorkOutcome } from './workActivity.mjs';
 /** One leased incoming ticket, drafted by this machine's read-only CLI. */
 import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
@@ -39,12 +40,17 @@ export function createWorkIntake({
   const claim = (id) =>
     claimFleetLease(claiming, { id }, { won: (r) => r.status === 200 && r.json?.ok === true });
 
-  const report = async (body) => {
+  const sendReport = async (body) => {
     await postBestEffort(done, { ...body, instance: DAEMON_INSTANCE });
   };
 
   const run = async (job, releaseSlot) => {
     const id = String(job.id);
+    const work = { kind: 'intake', id, name: job.title || 'Incoming ticket', turnId: id };
+    const report = body => {
+      reportWorkOutcome(work, { outcome: body.outcome === INTAKE_OUTCOMES.drafted ? 'drafted' : 'nothing', answer: body.error });
+      return sendReport(body);
+    };
     // No stand-down check here, as in the plan lane: a standing-down loop stops
     // processing the roster, and the one spawn gate is runTurn's own
     // (standDownGate.mjs; its pin keeps the askers few).
@@ -80,7 +86,7 @@ export function createWorkIntake({
             cwd: repoRoot,
             runtime,
             answerFromResult: true,
-            label: c.cyan('[intake]'),
+            work,
             // There is no MCP principal for a ticket, and no model or effort pin:
             // this one-shot reader uses the machine's consult defaults.
             onUsage: (u) => { usage = addUsage(usage, { ...u, runtime }); },

package/bin/lib/workMergeBatch.mjs

@@ -1,3 +1,5 @@
+import { reportWorkOutcome } from './workActivity.mjs';
+import { createTurnOutput } from './turnOutput.mjs';
 /** The daemon holds every selected place while one personal CLI integrates it. */
 import { trackedRepositorySetup } from './repositorySetup.mjs';
 import { git } from './git.mjs';
@@ -25,6 +27,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
   };
   return async (job) => {
     const spec = job.batch.spec;
+    const work = { kind: 'batch merge', id: spec.id, name: 'Selected merge', turnId: spec.id };
     const hold = admit?.('churn');
     if (hold) return;
     const release = admit?.reserve?.() ?? (() => {});
@@ -33,6 +36,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
       const claim = await request('agent-merge-batch-claim', { batchId: spec.id });
       if (!claim?.claimed) return;
       claimed = true;
+      createTurnOutput({ work }).event('Merge started', 'start');
       if (spec.members.some((m) => !isSafePathSegment(m.placeId))) throw new Error('A selected agent has no valid worktree identity.');
       // Renewal covers a long coordinator or validation command, not just Git beats.
       timer = setInterval(() => { void request('agent-merge-batch-progress', { batchId: spec.id, progress: {} }).catch(() => {}); }, 60_000);
@@ -68,7 +72,7 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
                 turnArgs: { prompt: mergeBatchPrompt(context), system: MERGE_BATCH_SYSTEM,
                   runtime, profile: 'build', knowledgeDir: knowledgeDirFor(repoRoot), model: leader.model || undefined, effort: leader.effort || undefined,
                   cwd: context.repositories[0].integrationWorktree, writableDirs: context.repositories.filter((r) => !r.alreadyLanded).map((r) => r.integrationWorktree),
-                  answerFromResult: true, label: '[batch merge]' } });
+                  answerFromResult: true, work } });
               if (result.wedged) throw new Error('The coordinating CLI ran out of time. Retry the batch to continue with its saved integration work.');
               return candidateObjects(String(result.out ?? '')).find((r) => r.status === 'delivered' || r.status === 'blocked');
             } finally { if (child) groupKillChildren?.delete(child); }
@@ -84,9 +88,11 @@ export function createWorkMergeBatch({ repositoryPlaces, repoRoot, baseDir, inPl
         reporting = true;
         const done = await request('agent-merge-batch-done', { batchId: spec.id, ok: true });
         if (!done?.settled) throw new Error('The combined merge result has not been acknowledged. Retry will remeasure base.');
+        reportWorkOutcome(work, { outcome: 'merged' });
         onRepoChanged(); landed.observe();
       });
     } catch (e) {
+      if (claimed) reportWorkOutcome(work, { outcome: 'nothing', answer: relayedText([e?.stdout, e?.stderr, e?.message].filter(Boolean).join('\n')) });
       // After a successful push/report attempt, leave the lease for replay: a transport
       // failure says nothing about whether the server committed the final receipt.
       if (claimed && !reporting) {