flowviant 0.125.7 → 0.125.12

package/bin/lib/workAgentMerges.mjs

@@ -1,3 +1,5 @@
+import { reportWorkOutcome } from './workActivity.mjs';
+import { createTurnOutput } from './turnOutput.mjs';
 import { mergeRepositoryPlace } from './repositoryMerge.mjs';
 import { fleetRequest } from './fleetPost.mjs';
 /** Agent merge claims, pull-request approval, and branch cleanup. */
@@ -13,7 +15,9 @@ import { gitMergeIn } from './gitMergeIdentity.mjs';
 import { warn } from './ui.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
-import { claimFleetLease, settleLease } from './fleetPost.mjs';
+import { claimFleetLease } from './fleetPost.mjs';
+import { createMergeReports } from './agentMergeReports.mjs';
+import { gitReportedConflict, recordMergeFailure, clearMergeFailure } from './agentMergeResolution.mjs';
 import { worktreePath } from './workPlaces.mjs';
 
 /** Git puts merge conflicts on stdout, while refusals usually use stderr.
@@ -46,7 +50,7 @@ export function createWorkAgentMerges({
   agentPublished,
 }) {
   const AGENT_MERGE_CLAIM_URL = fleetEndpoint('agent-merge-claim', FLEET_URL);
-  const AGENT_MERGE_DONE_URL = fleetEndpoint('agent-merge-done', FLEET_URL);
+
 
   // ── THE MERGE ──────────────────────────────────────────────────────────────
   //
@@ -63,9 +67,28 @@ export function createWorkAgentMerges({
   // The peer may hold it; doing nothing is the safe answer.
   const claimAgentMerge = (agentId) => claimFleetLease(AGENT_MERGE_CLAIM_URL, { agentId });
 
-  // On a failure the lease lapses and the job is re-offered — a merge is
-  // idempotent against an already-merged branch, which mergeOutward detects.
-  const postAgentMerge = (body) => settleLease(AGENT_MERGE_DONE_URL, body, { timeoutMs: 30_000 });
+  const retirements = new Map();
+  // Remote cleanup is tail work, after acknowledgement and outside the place
+  // lock, for both immediate delivery and journal replay.
+  const retireAgentMerge = async (id) => {
+    const held = retirements.get(id);
+    if (!held) return;
+    retirements.delete(id);
+    const { body, place, publishedRef } = held;
+    if (!isSafePathSegment(place)) return;
+    clearMergeFailure(worktreePath(baseDir, place));
+    agentPublished.delete(place);
+    agentRemoteAt.delete(place);
+    const args = publishDeleteArgs(publishedRef);
+    if (args) {
+      try { gitNet(args, 60_000); }
+      catch (e) { warn(`agent ${body.agentId}: the published branch could not be deleted — ${publishErrorText(envScrub(e?.stderr?.toString?.() || e?.message || ''))}`); }
+    }
+  };
+  const reports = createMergeReports({ baseDir, delivered: async (held, settled) => {
+    if (held.body.ok && settled) retirements.set(String(held.body.agentId), held);
+  } });
+  const postAgentMerge = (body, meta) => reports.report(body, meta);
 
   // A merge COMMIT needs an identity the machine may not have; the probe and
   // the daemon's fallback live in gitMergeIdentity.mjs.
@@ -81,6 +104,8 @@ export function createWorkAgentMerges({
       return;
     }
     if (!(await claimAgentMerge(agentId))) return;
+    const activity = createTurnOutput({ work: { kind: 'merge', id: agentId, name: job.agentName || agentId } });
+    activity.event('Merge started', 'start');
 
     /**
      * NO EXIT PATH MAY LEAVE A CLAIMED MERGE UNREPORTED — the same belt the
@@ -111,11 +136,17 @@ export function createWorkAgentMerges({
      * landed is the case it exists for. It is recorded in `report` rather than
      * at the three success sites so a fourth one cannot forget it.
      */
-    let landedRef = null;
     const report = async (body) => {
+      const wt = worktreePath(baseDir, place);
+      if (!job.repositoryMerge && !body.ok) {
+        body.conflict ??= gitReportedConflict(null, wt);
+        recordMergeFailure(wt, baseRef(), body.conflict);
+      }
+      // From here the journal owns retries, including a dropped 200 or a
+      // restart. The catch must not overwrite this measured outcome.
       reported = true;
-      if (body?.ok === true) landedRef = job.publishedRef ?? null;
-      await postAgentMerge({ ...body, ...(body.detail ? { detail: relayedText(String(body.detail)).slice(0, 2000) } : {}) });
+      reportWorkOutcome({ ...activity.identity, id: activity.identity.workId }, { outcome: body.ok ? 'merged' : 'nothing', answer: body.detail });
+      await postAgentMerge({ ...body, ...(body.detail ? { detail: relayedText(String(body.detail)).slice(0, 2000) } : {}) }, { place, publishedRef: job.publishedRef ?? null });
     };
 
     // A WRITER on the place, exactly as a ship is. It folds base in and pushes
@@ -160,6 +191,7 @@ export function createWorkAgentMerges({
             agentId,
             ok: false,
             detail: agentMergeFailureDetail(e),
+            conflict: gitReportedConflict(e, wt),
           });
           return;
         }
@@ -168,7 +200,11 @@ export function createWorkAgentMerges({
         // anything merges: a failed merge sends the agent BACK to review, which
         // is a review-entry beat like any other, and a stale reading standing
         // over a rebased branch is exactly what `precheckSha` exists to void.
-        await runReviewEntry(agentId, wt, job.agentName);
+        const check = await runReviewEntry(agentId, wt, job.agentName);
+        if (check?.status === 'failed') {
+          await report({ agentId, ok: false, detail: check.text || check.output || 'The repository check failed after folding base.' });
+          return;
+        }
       }
       // `git()` THROWS on a non-zero exit, and `symbolic-ref` exits non-zero on
       // a detached HEAD — so the guard below was unreachable and the throw
@@ -367,11 +403,11 @@ export function createWorkAgentMerges({
           agentId,
           ok: false,
           // WHOSE FIX IT IS (0.108.0), when the merge said: a refusal about
-          // the person's side (`shipMerge.mjs`'s dirty checkout) queues no
-          // resolve turn on the server. A conflict says nothing, and the
-          // agent resolves it in its worktree as before.
+          // person's side must become a question during diagnosis; it is
+          // never permission to modify that checkout or its credentials.
           ...(e?.fix === 'person' ? { fix: 'person' } : {}),
           detail: agentMergeFailureDetail(e),
+          conflict: gitReportedConflict(e, wt),
         });
         return;
       }
@@ -388,62 +424,31 @@ export function createWorkAgentMerges({
     } finally {
       if (!reported) {
         // Belt over braces. A merge this daemon claimed and cannot account for
-        // is a FAILURE, said out loud, so the agent goes back to Review with a
+        // is a FAILURE, said out loud, so the agent resumes diagnosis with a
         // reason instead of waiting out an expiry that blames nobody.
         await postAgentMerge({
           agentId,
           ok: false,
           detail: 'the merge did not complete — check the daemon log',
-        }).catch(() => {});
-      }
-      /**
-       * …AND THE RETIREMENT IS TAIL WORK, OUTSIDE THE PLACE LOCK — the same
-       * placement the turn's publish argues for, for the same reason.
-       *
-       * `gitNet` is `execFileSync`: it blocks the whole event loop for up to its
-       * timeout, and inside `inPlace(place, true, …)` it would hold this
-       * agent's WRITER lock through a remote's bad day, with the merge already
-       * settled and nothing left that the delay serves. This block is PAST the
-       * lock: `inPlace` has returned (or thrown) before a `finally` runs.
-       *
-       * IN THE `finally` rather than after it, so a throw between the ok settle
-       * and the end of the locked block cannot strand the ref. `landedRef` is
-       * set only by a reported success, so there is nothing here to run on any
-       * other path — and a remote that refuses the delete only warns: the merge
-       * is the thing that matters, and a landed branch must not become a failed
-       * approval.
-       *
-       * The record goes with the ref. `agentPublished` is what the SWEEP
-       * republishes from, so leaving the entry behind would let the next sweep
-       * push the ref straight back — an orphan no later merge job can ever
-       * carry, and therefore one nothing can delete.
-       */
-      if (landedRef) {
-        agentPublished.delete(place);
-        agentRemoteAt.delete(place);
-        const args = publishDeleteArgs(landedRef);
-        if (args) {
-          try {
-            gitNet(args, 60_000);
-          } catch (e) {
-            warn(
-              `agent ${agentId}: the published branch ${landedRef} could not be deleted — ${publishErrorText(envScrub(e?.stderr?.toString?.() || e?.message || ''))}`
-            );
-          }
-        }
+        }, { place, publishedRef: job.publishedRef ?? null }).catch(() => {});
       }
+      await retireAgentMerge(agentId);
     }
   };
 
   const processAgentMergeJobs = (jobs) => {
+    void (async () => {
+      await reports.flush();
+      for (const id of [...retirements.keys()]) if (!agentMerges.has(id)) await retireAgentMerge(id);
+    })().catch(() => {});
     if (!Array.isArray(jobs) || jobs.length === 0) return;
     for (const job of jobs.slice(0, 2)) {
       const id = String(job?.batch?.spec?.id || job?.agentId || '');
-      if (!id || agentMerges.has(id)) continue;
+      if (!id || agentMerges.has(id) || reports.pending.has(id)) continue;
       agentMerges.add(id);
       void (job.batch ? runBatch(job) : runAgentMerge(job)).finally(() => agentMerges.delete(id));
     }
   };
 
-  return { processAgentMergeJobs, agentMerges };
+  return { processAgentMergeJobs, agentMerges, pendingMergeReports: reports.pending };
 }

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,9 @@
+import { imageRevisionInstructions } from './artifactIteration.mjs';
+import { measureTestFindings } from './testFindings.mjs';
+import { fetchResultInputs } from './resultInputs.mjs';
+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 +24,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 +55,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';
 
@@ -267,6 +275,7 @@ export function createAgentTurnExecution({
      * No key is no call: a turn without files touches nothing here, and its
      * prompt is byte-for-byte what it was.
      */
+    await fetchResultInputs(wt, job.resultInputs);
     const files =
       Array.isArray(job.attachments) && job.attachments.length > 0
         ? await fetchAgentFiles(wt, job.attachments)
@@ -304,10 +313,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 +362,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 +399,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.
@@ -397,13 +412,20 @@ export function createAgentTurnExecution({
     /** The agent's artifact directory as it stood before this turn — the
      *  tab lane's rule, in the agent's own worktree (2026-09-22). */
     const artifactsBefore = beforeArtifacts(wt);
-    const artifactInstructions = getArtifactsAccepted()
+    let artifactInstructions = getArtifactsAccepted()
       ? await artifacts.prepare?.({ placeDir: wt, before: artifactsBefore, agentId }) ?? '' : '';
+    if (job.imageRevision) {
+      artifactsBefore.imageRevision = job.imageRevision;
+      artifactInstructions += '\n\n' + imageRevisionInstructions(job.imageRevision, job.resultInputs);
+    }
     let projectTools = null;
     let orchestrator = null;
     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 +446,11 @@ 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,
+        resultInputs: job.resultInputs,
+        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, taskType: job.task?.taskType, 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 +490,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: (() => {
@@ -743,6 +768,9 @@ export function createAgentTurnExecution({
       wt,
     });
     if (res) setRuntimeLimit(PROJECT_ID, rt, null);
+    if (body.outcome === 'delivered' && job.task?.taskType === 'tests' && res?.testFindings) {
+      body.testFindings = measureTestFindings(res.testFindings, repositoryRun?.sourcesNow() ?? [{ wt, baseRef: baseRef(), id: job.repos?.length === 1 ? job.repos[0] : null }], envScrub);
+    }
     if (limit) {
       setRuntimeLimit(PROJECT_ID, rt, limit);
       // Every agent ON THIS CLI parks, because that account is shared: one
@@ -752,7 +780,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/workAgentTurnOutcome.mjs

@@ -159,14 +159,23 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
       turnId,
       ...(prerequisite && !cannotRequest ? { prerequisite } : {}),
       outcome: res.outcome,
-      answer: cannotRequest ?? envScrub(kind.posture === 'research' && researchUse
-        ? withResearchHeader(researchUse, res.answer ?? '') : res.answer ?? ''),
+      answer: cannotRequest ?? envScrub((kind.posture === 'research' && researchUse
+        ? withResearchHeader(researchUse, res.answer ?? '') : res.answer ?? '') +
+        (job.task?.taskType === 'tests' && res.raised?.length ? '\n\nAdditional CLI-reported findings (not filed as fixes):\n' + res.raised.map(r => `${r.title}\n${r.brief ?? ''}`).join('\n\n') : '')),
+      // CLI-authored evidence travels separately from the short answer and
+      // measured commits/checks. Older turns simply send no report.
+      ...(kind.posture === 'build' && res.outcome === 'delivered' && res.verification
+        ? { verification: envScrub(res.verification) } : {}),
+      ...(kind.posture === 'build' && res.outcome === 'delivered' && res.handover
+        ? { handover: envScrub(res.handover) } : {}),
+      ...(kind.posture === 'build' && res.outcome === 'delivered' && res.automation
+        ? { automation: envScrub(res.automation) } : {}),
       ...(commits.length ? { commits } : {}),
       // SCRUBBED like the answer beside it: a raised card lands in the
       // project doc every member reads, and a brief quoting the `.env` the
       // agent just read ("value sk_live_… is logged in pay.ts") went out
       // verbatim while the same value in the summary was redacted.
-      ...(res.raised?.length
+      ...(job.task?.taskType !== 'tests' && res.raised?.length
         ? {
             raised: res.raised.map((r) => ({
               title: envScrub(r.title).slice(0, 300),