@yagni-app/code-staging 1.2.6-staging.1952.1 → 1.2.6-staging.1956.1

package/dist/extension/pipeline/orchestrator.js

@@ -26,14 +26,15 @@
  */
 import { addRunUsage, aggregateRunUsage, DEFAULT_RUN_BUDGET, DEFAULT_STAGE_ESTIMATE_MS, EMPTY_RUN_USAGE, exceedsBudget, stageWall, stageWontFit, } from "./budget.js";
 import { attributeFindings, checkerFindings, composeFixNote, composeResidue, composeSynthesizerInput, mergeFindings, parseOpenFindings, renderFindings, stripOpenFindings, } from "./checker.js";
-import { auditClaims, parsePartition } from "./fanout.js";
-import { extractFindingsBlock, hasBlockingFindings, isBlockingFinding, parseFindings, shouldStop, unionFindings } from "./findings.js";
+import { auditClaims, parsePartition, } from "./fanout.js";
+import { extractFindingsBlock, hasBlockingFindings, isBlockingFinding, parseFindings, shouldStop, unionFindings, } from "./findings.js";
 import { limitedMapFiles, readTouchedFiles } from "./fixRound.js";
 import { missionDesignContext, missionSeed, missionSkippedStages, normalizeMission, PINNED_DESIGN_MARKER, } from "./mission.js";
 import { withResilience } from "./resilience.js";
 import { runStage as defaultRunStage } from "./runner.js";
 import { makeRunVerify, makeWorkstreamCheck, parseChangedPaths, } from "./verify.js";
-import { builderStage, fixerStage, fixRoundImplementStage, fixRoundMapStage, orchestratorStage, partitionReaskStage, PARTITION_CALLER_LABEL, REQUIRED_LENSES, REVIEW_LENSES, reaskStage, reviewStage, selectStages, synthesizerFixStage, synthesizerStage, SYNTHESIZER_CALLER_LABEL, workstreamCallerLabel, } from "./stages.js";
+import { extractPlanJson } from "./planOutput.js";
+import { builderStage, fixerStage, fixRoundImplementStage, fixRoundMapStage, FULL_LANE, orchestratorStage, partitionReaskStage, PARTITION_CALLER_LABEL, planJsonReaskStage, REQUIRED_LENSES, reaskStage, reviewStage, synthesizerFixStage, synthesizerStage, SYNTHESIZER_CALLER_LABEL, workstreamCallerLabel, } from "./stages.js";
 import { snapshotWorkspace as defaultSnapshotWorkspace, workspaceChanged } from "./workspace.js";
 import { DEFAULT_RESILIENCE_POLICY, MAX_CONCURRENCY, MAX_FANOUT_CONCURRENCY, MAX_FANOUT_CONCURRENCY_ULTRA, MAX_FIX_TURNS, MIN_TOOL_CALLS_FOR_HEALTH, TOOL_ERROR_FAIL_RATE, } from "./types.js";
 /** Each review round's findings as the host stores them: bounded, messages clipped. */
@@ -95,7 +96,10 @@ function toolFailureReason(r) {
  * that exits 0 while most of its edits failed is not trusted on its prose alone.
  */
 function isFailed(r) {
-    return r.exitCode !== 0 || r.stopReason === "error" || r.stopReason === "aborted" || toolFailureExceeded(r);
+    return (r.exitCode !== 0 ||
+        r.stopReason === "error" ||
+        r.stopReason === "aborted" ||
+        toolFailureExceeded(r));
 }
 /**
  * A non-final build stage threads its `finalOutput` forward as the NEXT stage's
@@ -168,6 +172,10 @@ function creditExhaustionReason(r) {
         return undefined;
     return "the workspace is out of YAGNI credits (the model proxy returned 402). Top up credits, then re-run /go.";
 }
+/** How a reviewer is named in the round's record: its lens, or the lane's one reviewer. */
+function reviewerName(lens) {
+    return lens ?? "reviewer";
+}
 /** Render only the blocking findings as the fix stage's `{previous}` handoff. */
 function serializeBlocking(findings) {
     return findings
@@ -203,7 +211,11 @@ function composeFanHandoff(decision, workstreams, results, violations) {
         parts.push(`## ${w.name} (${w.tier})\nClaimed: ${w.files.join(", ")}\n\n${body}`);
     });
     if (violations.length > 0) {
-        parts.push(["## Out-of-claim edits", "These paths changed outside every workstream's claims:", ...violations.map((p) => `- ${p}`)].join("\n"));
+        parts.push([
+            "## Out-of-claim edits",
+            "These paths changed outside every workstream's claims:",
+            ...violations.map((p) => `- ${p}`),
+        ].join("\n"));
     }
     return parts.join("\n\n");
 }
@@ -231,7 +243,9 @@ async function mapWithConcurrencyLimit(items, concurrency, fn) {
  * floor and run past the deadline, so it fails instead of retrying.
  */
 export function stageRunnerPolicy(budget) {
-    return budget.deadlineMs === undefined ? DEFAULT_RESILIENCE_POLICY : { ...DEFAULT_RESILIENCE_POLICY, retryWallTimeout: false };
+    return budget.deadlineMs === undefined
+        ? DEFAULT_RESILIENCE_POLICY
+        : { ...DEFAULT_RESILIENCE_POLICY, retryWallTimeout: false };
 }
 /**
  * The pipeline's default stage runner: `base` under the R1 resilience wrapper
@@ -286,7 +300,9 @@ export async function runPipeline(ticket, deps) {
     // `go:implement:<workstream>`), so per-workstream spend attributes for free the
     // way review lenses do. Every other stage leaves it undefined and keeps the
     // runner's own `go:<stage>` default.
-    // `writes` marks a build or fix child, the only ones that get `extraArgs`.
+    // `writes` marks a child that gets `extraArgs` (the Team's skills): a build or
+    // fix child, and on a lane with `skillsEveryStage` (the cloud session) its
+    // plan and review children too (spec decision 4).
     const stageDepsFor = (tag, callerLabel, writes = false) => {
         const onEvent = deps.onEvent;
         return {
@@ -311,9 +327,10 @@ export async function runPipeline(ticket, deps) {
     // The text the stages plan against: the resolved ticket brief (verbatim title +
     // body) when /go could fetch it, else the raw ticket reference (honest blind).
     const promptTicket = deps.ticketBrief ?? ticket;
-    // M6: default grounded + the full stage list; the blind eval lane overrides both.
+    // M6: default grounded + the lane's stage list; the blind eval lane overrides both.
     const grounded = deps.grounded !== false;
-    const all = deps.stages ?? selectStages("full");
+    const lane = deps.lane ?? FULL_LANE;
+    const all = deps.stages ?? lane.stages;
     // R3-b: aggregate usage ceiling, checked at each stage boundary.
     const budget = deps.budget ?? DEFAULT_RUN_BUDGET;
     // Mission mode (spec: sandbox harness parity). The factory produced the plan
@@ -376,7 +393,8 @@ export async function runPipeline(ticket, deps) {
     let reviewInput = resume ? resume.reviewInput : "";
     const designMarker = PINNED_DESIGN_MARKER;
     const resumedDesignOffset = reviewInput.indexOf(designMarker);
-    let designContext = missionDesignContext(mission) ?? (resumedDesignOffset >= 0 ? reviewInput.slice(resumedDesignOffset) : undefined);
+    let designContext = missionDesignContext(mission) ??
+        (resumedDesignOffset >= 0 ? reviewInput.slice(resumedDesignOffset) : undefined);
     let stopReason = "clean";
     // P4: honest note carried out when the verify gate could not give a verdict on
     // the final round (no command / unrunnable), so /go never claims a build it did
@@ -402,7 +420,10 @@ export async function runPipeline(ticket, deps) {
     const observedMs = {};
     const wontFit = (kind) => stageWontFit(budget, kind, observedMs[kind] ?? DEFAULT_STAGE_ESTIMATE_MS[kind], clock());
     if (deps.continuation) {
-        log("continuation", { stageAtStop: deps.continuation.stageAtStop, resumedAtRound: resume ? resume.round : null });
+        log("continuation", {
+            stageAtStop: deps.continuation.stageAtStop,
+            resumedAtRound: resume ? resume.round : null,
+        });
     }
     // The map stage's brief, kept for the partitioner's repo context. Absent on a
     // mission run (map is skipped there — the injected memo stands in) and on any
@@ -470,7 +491,10 @@ export async function runPipeline(ticket, deps) {
     const runImplementChecker = async (args) => {
         const { stage, workstreams, handoff } = args;
         const fanned = workstreams.length > 0;
-        const targets = workstreams.map((w) => ({ name: w.name, files: w.files }));
+        const targets = workstreams.map((w) => ({
+            name: w.name,
+            files: w.files,
+        }));
         let report = await runChecker(targets);
         let body = handoff;
         // Defects the SYNTHESIZER named in its latest summary, kept apart from the
@@ -513,7 +537,10 @@ export async function runPipeline(ticket, deps) {
                 const fixes = await mapWithConcurrencyLimit(assigned, ceiling, async (a) => {
                     const siblings = workstreams.filter((s) => s.name !== a.workstream.name);
                     progress({ kind: "stage_start", stageId: stage.id, workstream: a.workstream.name });
-                    const fixed = await runStageFn({ ...fixerStage(a.workstream, renderFindings(a.findings), siblings), tools: stage.tools }, { ticket: promptTicket, grounded }, stageDepsFor({ stageId: stage.id, workstream: a.workstream.name }, workstreamCallerLabel(a.workstream.name), true));
+                    const fixed = await runStageFn({
+                        ...fixerStage(a.workstream, renderFindings(a.findings), siblings),
+                        tools: stage.tools,
+                    }, { ticket: promptTicket, grounded }, stageDepsFor({ stageId: stage.id, workstream: a.workstream.name }, workstreamCallerLabel(a.workstream.name), true));
                     progress({
                         kind: "stage_done",
                         stageId: stage.id,
@@ -527,7 +554,9 @@ export async function runPipeline(ticket, deps) {
                 // A fix turn that CRASHED does not fail the stage: the merged candidate is
                 // still real work, the re-check below will simply still see the findings,
                 // and the cap bounds how long that can go on. Recorded, never silent.
-                const brokenFixes = fixes.map((r, i) => (isFailed(r) ? assigned[i].workstream.name : null)).filter(Boolean);
+                const brokenFixes = fixes
+                    .map((r, i) => (isFailed(r) ? assigned[i].workstream.name : null))
+                    .filter(Boolean);
                 if (brokenFixes.length > 0)
                     log("fix_turn_child_failed", { turn, workstreams: brokenFixes });
             }
@@ -537,7 +566,9 @@ export async function runPipeline(ticket, deps) {
             // is the one child with no claims, so it must not write while they do.
             if (unassigned.length > 0) {
                 const findingsText = renderFindings(unassigned);
-                const fixStage = fanned ? synthesizerFixStage(findingsText) : fixerStage(undefined, findingsText);
+                const fixStage = fanned
+                    ? synthesizerFixStage(findingsText)
+                    : fixerStage(undefined, findingsText);
                 const fixed = await runStageFn({ ...fixStage, tools: stage.tools }, { ticket: promptTicket, grounded }, stageDepsFor({ stageId: stage.id }, fanned ? SYNTHESIZER_CALLER_LABEL : undefined, true));
                 stages.push(fixed);
                 if (fanned) {
@@ -575,6 +606,29 @@ export async function runPipeline(ticket, deps) {
             return `${body}\n\n${composeFixNote(turn)}`;
         return body;
     };
+    /**
+     * One writer builds the plan, then the implement checker's verify and
+     * bounded fix turns run on its tree. The diamond's single-writer verdict
+     * runs this, and so does a lane with no fan-out (the cloud lane), where no
+     * partitioner runs at all.
+     */
+    const runOneWriter = async (stage, previous) => {
+        const written = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }, undefined, true));
+        stages.push(written);
+        // A failed or credit-starved writer never reaches the checker: the build
+        // loop's own guard turns it into `partial` or the honest stage error, and
+        // verifying a tree nobody finished writing would only add noise.
+        if (isFailed(written) || creditExhaustionReason(written) || deps.signal?.aborted)
+            return written;
+        // Decision 7: the fix loop applies identically here: the same checker gate,
+        // the same one builder re-engaged, the same cap.
+        const text = await runImplementChecker({
+            stage,
+            workstreams: [],
+            handoff: written.finalOutput,
+        });
+        return text === written.finalOutput ? written : { ...written, finalOutput: text };
+    };
     /**
      * The implement diamond (spec "Diamond execution"). Returns the StageResult the
      * build loop treats as "the implement stage". The diamond owns `stages` for the
@@ -606,17 +660,7 @@ export async function runPipeline(ticket, deps) {
         const partitionTag = { stageId: stage.id };
         const runSingleWriter = async (decision) => {
             recordDecision(decision, beforeBuild);
-            const written = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }, undefined, true));
-            stages.push(written);
-            // A failed or credit-starved writer never reaches the checker: the build
-            // loop's own guard turns it into `partial` or the honest stage error, and
-            // verifying a tree nobody finished writing would only add noise.
-            if (isFailed(written) || creditExhaustionReason(written) || deps.signal?.aborted)
-                return written;
-            // Decision 7: the fix loop applies identically here — the same checker gate,
-            // the same one builder re-engaged, the same cap.
-            const text = await runImplementChecker({ stage, workstreams: [], handoff: written.finalOutput });
-            return text === written.finalOutput ? written : { ...written, finalOutput: text };
+            return runOneWriter(stage, previous);
         };
         const partition = await runStageFn(partitionStage, { ticket: promptTicket, previous, grounded }, stageDepsFor(partitionTag, PARTITION_CALLER_LABEL));
         stages.push(partition);
@@ -682,7 +726,10 @@ export async function runPipeline(ticket, deps) {
         // actually runs at once, so a width-8 partition runs 4-at-a-time outside ultra
         // rather than being refused.
         const ceiling = deps.isUltra?.() ? MAX_FANOUT_CONCURRENCY_ULTRA : MAX_FANOUT_CONCURRENCY;
-        log("fanout_start", { width: workstreams.length, concurrency: Math.min(workstreams.length, ceiling) });
+        log("fanout_start", {
+            width: workstreams.length,
+            concurrency: Math.min(workstreams.length, ceiling),
+        });
         const builders = await mapWithConcurrencyLimit(workstreams, ceiling, async (w) => {
             const siblings = workstreams.filter((s) => s.name !== w.name);
             // Per-builder lifecycle, exactly the review fan-out's shape: each child
@@ -701,7 +748,9 @@ export async function runPipeline(ticket, deps) {
             return built;
         });
         stages.push(...builders);
-        const builderCredit = builders.map((r) => creditExhaustionReason(r)).find((v) => Boolean(v));
+        const builderCredit = builders
+            .map((r) => creditExhaustionReason(r))
+            .find((v) => Boolean(v));
         if (builderCredit) {
             log("pipeline_failed", { stageId: stage.id, reason: builderCredit });
             throw new PipelineStageError(stage.id, `Pipeline stopped at ${stage.id}: ${builderCredit}`, stages);
@@ -740,12 +789,19 @@ export async function runPipeline(ticket, deps) {
             // Summed for honesty in logs and handoffs only: this object is NEVER pushed
             // into `stages` (its children already are), so the run's usage is counted once.
             usage: sumStageUsage(builders),
-            stderr: builders.map((r) => r.stderr).filter(Boolean).join("\n"),
+            stderr: builders
+                .map((r) => r.stderr)
+                .filter(Boolean)
+                .join("\n"),
             toolCalls: builders.reduce((n, r) => n + r.toolCalls, 0),
             toolErrors: builders.reduce((n, r) => n + r.toolErrors, 0),
             ...(failed.length > 0 ? { stopReason: "error", errorMessage: failureNote } : {}),
         };
-        log("fanout_done", { width: workstreams.length, failed: failed.map((f) => f.name), violations: violations.length });
+        log("fanout_done", {
+            width: workstreams.length,
+            failed: failed.map((f) => f.name),
+            violations: violations.length,
+        });
         return summary;
     };
     /** Emit + journal the diamond's verdict the moment it resolves (decision 2). */
@@ -806,7 +862,10 @@ export async function runPipeline(ticket, deps) {
         try {
             const read = await (deps.readTouchedFiles ?? readTouchedFiles)(deps.cwd, fixInputs.baseRef, deps.signal);
             if (read === null) {
-                log("fix_round_touched_unread", { baseRef: fixInputs.baseRef ?? null, error: "git could not list the touched files" });
+                log("fix_round_touched_unread", {
+                    baseRef: fixInputs.baseRef ?? null,
+                    error: "git could not list the touched files",
+                });
             }
             touched = read ?? [];
         }
@@ -853,9 +912,9 @@ export async function runPipeline(ticket, deps) {
                 return done("budget_exceeded");
             }
         }
-        // One builder at the standard tier: the partition decision is recorded as
+        // One builder at the lane's fix tier: the partition decision is recorded as
         // single so the run's record still says how it was built.
-        const implementDef = fixRoundImplementStage(all.find((s) => s.id === "implement"));
+        const implementDef = fixRoundImplementStage(all.find((s) => s.id === "implement"), fix.model);
         const previous = [
             brief || "(No map brief: work from the findings, files and lines the ticket lists.)",
             designContext,
@@ -870,9 +929,15 @@ export async function runPipeline(ticket, deps) {
         log("stage_done", { stageId: "implement", exitCode: written.exitCode });
         const credit = creditExhaustionReason(written);
         if (isFailed(written)) {
-            const why = credit ?? toolFailureReason(written) ?? (written.errorMessage || written.stderr || written.finalOutput || "(no output)");
-            const killedMidWork = written.exitCode !== 0 || written.stopReason === "aborted" || written.stopReason === "error";
-            if (killedMidWork && !deps.signal?.aborted && workspaceChanged(beforeBuild, await snapshotFn(deps.cwd, deps.signal))) {
+            const why = credit ??
+                toolFailureReason(written) ??
+                (written.errorMessage || written.stderr || written.finalOutput || "(no output)");
+            const killedMidWork = written.exitCode !== 0 ||
+                written.stopReason === "aborted" ||
+                written.stopReason === "error";
+            if (killedMidWork &&
+                !deps.signal?.aborted &&
+                workspaceChanged(beforeBuild, await snapshotFn(deps.cwd, deps.signal))) {
                 log("pipeline_partial", { stageId: "implement", reason: why });
                 return done("partial");
             }
@@ -887,7 +952,11 @@ export async function runPipeline(ticket, deps) {
             return done("aborted");
         // Verify: the plan's checks (and the pull request's CI jobs) on the tree,
         // with the same bounded fix turns as any implement stage.
-        await runImplementChecker({ stage: implementDef, workstreams: [], handoff: written.finalOutput });
+        await runImplementChecker({
+            stage: implementDef,
+            workstreams: [],
+            handoff: written.finalOutput,
+        });
         progress({ kind: "stage_done", stageId: "implement" });
         stageEvent("implement", "finish");
         if (deps.signal?.aborted)
@@ -905,7 +974,11 @@ export async function runPipeline(ticket, deps) {
             verifyCommand = undefined;
         }
         const open = lastChecker?.open ?? [];
-        writeCheckpoint(mkRecord("build_done", { snapshot: afterBuild, reviewInput: written.finalOutput, usage: currentUsage() }));
+        writeCheckpoint(mkRecord("build_done", {
+            snapshot: afterBuild,
+            reviewInput: written.finalOutput,
+            usage: currentUsage(),
+        }));
         return done(open.length > 0 ? "round_cap" : "clean", open);
     };
     const fixRound = !resume && deps.fixRound && !deps.fixRound.replan ? deps.fixRound : undefined;
@@ -920,7 +993,13 @@ export async function runPipeline(ticket, deps) {
         if (over) {
             log("pipeline_stop", { reason: "budget_exceeded", where: "resume", detail: over });
             progress({ kind: "done", stopReason: "budget_exceeded" });
-            return { stages, rounds, stopReason: "budget_exceeded", findings: rounds[rounds.length - 1]?.findings ?? [], decisionsRecorded };
+            return {
+                stages,
+                rounds,
+                stopReason: "budget_exceeded",
+                findings: rounds[rounds.length - 1]?.findings ?? [],
+                decisionsRecorded,
+            };
         }
     }
     else if (fixRound) {
@@ -944,8 +1023,16 @@ export async function runPipeline(ticket, deps) {
         baselinePaths = parseChangedPaths(beforeBuild.status);
         // Sequential build half — stop at the first failure (mirrors the chain).
         for (const stage of buildStages) {
-            if (stage.id === "plan" && !mission && deps.prepareDesign && !deps.signal?.aborted && !overBudget()) {
-                const prepared = await deps.prepareDesign({ ticket: promptTicket, exploration: previous ?? "", signal: deps.signal });
+            if (stage.id === "plan" &&
+                !mission &&
+                deps.prepareDesign &&
+                !deps.signal?.aborted &&
+                !overBudget()) {
+                const prepared = await deps.prepareDesign({
+                    ticket: promptTicket,
+                    exploration: previous ?? "",
+                    signal: deps.signal,
+                });
                 designContext = prepared ? `${designMarker}\n${prepared}` : undefined;
                 if (designContext)
                     previous = `${previous ?? ""}\n\n${designContext}`;
@@ -958,10 +1045,12 @@ export async function runPipeline(ticket, deps) {
             // boundary, so nothing is pushed for it here.
             let r;
             if (stage.id === "implement") {
-                r = await runImplementDiamond(stage, previous, beforeBuild);
+                r = lane.fanout
+                    ? await runImplementDiamond(stage, previous, beforeBuild)
+                    : await runOneWriter(stage, previous);
             }
             else {
-                r = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }));
+                r = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }, undefined, lane.skillsEveryStage));
                 stages.push(r);
             }
             log("stage_done", { stageId: stage.id, exitCode: r.exitCode });
@@ -973,16 +1062,23 @@ export async function runPipeline(ticket, deps) {
             // The final build stage (implement) is exempt: its handoff is the diff, not
             // prose, so `incompleteHandoff` never flags it.
             if (!isFailed(r) && stage.id !== finalBuildId && incompleteHandoff(r)) {
-                log("stage_retry", { stageId: stage.id, attempt: 2, reason: "incomplete_handoff", stopReason: r.stopReason });
+                log("stage_retry", {
+                    stageId: stage.id,
+                    attempt: 2,
+                    reason: "incomplete_handoff",
+                    stopReason: r.stopReason,
+                });
                 progress({ kind: "stage_start", stageId: stage.id });
                 stageEvent(stage.id, "start");
-                r = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }));
+                r = await runStageFn(stage, { ticket: promptTicket, previous, grounded }, stageDepsFor({ stageId: stage.id }, undefined, lane.skillsEveryStage));
                 stages.push(r);
                 log("stage_done", { stageId: stage.id, exitCode: r.exitCode, attempt: 2 });
             }
             const credit = creditExhaustionReason(r);
             if (isFailed(r)) {
-                const why = credit ?? toolFailureReason(r) ?? (r.errorMessage || r.stderr || r.finalOutput || "(no output)");
+                const why = credit ??
+                    toolFailureReason(r) ??
+                    (r.errorMessage || r.stderr || r.finalOutput || "(no output)");
                 // A WRITE stage (implement/fix) KILLED mid-work — a timeout or transient blip
                 // that aborted/errored the child once it had begun editing — leaves a real
                 // partial diff in the working tree. R1 deliberately does NOT retry such a stage
@@ -1037,10 +1133,36 @@ export async function runPipeline(ticket, deps) {
                     throw new PipelineStageError(stage.id, `Pipeline stopped at ${stage.id}: ${problem}`, stages);
                 }
             }
+            // A lane whose plan goes to its gate stops here, with the plan as the
+            // run's result. The plan must end on its ```plan-json block; one cheap
+            // re-ask recovers a plan that left it off.
+            if (lane.stopAfterPlan && stage.id === "plan") {
+                let plan = r.finalOutput;
+                if (plan.trim() && extractPlanJson(plan) === null && !deps.signal?.aborted) {
+                    const reask = await runStageFn(planJsonReaskStage(stage), { ticket: promptTicket, previous: plan, grounded }, stageDepsFor({ stageId: "plan" }));
+                    stages.push(reask);
+                    const recovered = !isFailed(reask) && extractPlanJson(reask.finalOutput) !== null;
+                    log("plan_json_reask", { recovered });
+                    if (recovered)
+                        plan = `${plan}\n\n${reask.finalOutput}`;
+                }
+                progress({ kind: "stage_done", stageId: "plan" });
+                stageEvent("plan", "finish", { output: plan });
+                const stop = deps.signal?.aborted
+                    ? "aborted"
+                    : plan.trim()
+                        ? "clean"
+                        : "failed";
+                log("pipeline_stop", { reason: stop, where: "plan" });
+                progress({ kind: "done", stopReason: stop });
+                return { stages, rounds, stopReason: stop, findings: [], decisionsRecorded, plan };
+            }
             progress({ kind: "stage_done", stageId: stage.id });
             // The plan finish carries its finalOutput so /go can record the plan onto the
             // work item; no other boundary streams the full stage text.
-            stageEvent(stage.id, "finish", stage.id === "plan" ? { output: designContext ? `${r.finalOutput}\n\n${designContext}` : r.finalOutput } : undefined);
+            stageEvent(stage.id, "finish", stage.id === "plan"
+                ? { output: designContext ? `${r.finalOutput}\n\n${designContext}` : r.finalOutput }
+                : undefined);
             // The map brief is the partitioner's repo context on an interactive run
             // (mission runs skip map and hand it the injected memo instead).
             if (stage.id === "map")
@@ -1077,11 +1199,19 @@ export async function runPipeline(ticket, deps) {
         // resume here instead of re-running map→plan→implement.
         writeCheckpoint(mkRecord("build_done", { snapshot: afterBuild, reviewInput, usage: currentUsage() }));
     }
+    // Each round's reviewers: the lane's lenses fanned out, or its one reviewer
+    // (no lens), who judges through every angle.
+    const reviewers = lane.reviewLenses.length > 0 ? [...lane.reviewLenses] : [undefined];
     while (true) {
         const reviewWontFit = wontFit("review");
         if (reviewWontFit) {
             stopReason = "budget_exceeded";
-            log("pipeline_stop", { reason: "budget_exceeded", phase: "review", round, detail: reviewWontFit });
+            log("pipeline_stop", {
+                reason: "budget_exceeded",
+                phase: "review",
+                round,
+                detail: reviewWontFit,
+            });
             break;
         }
         const reviewStartedAt = clock();
@@ -1102,12 +1232,12 @@ export async function runPipeline(ticket, deps) {
                 verifyError = err ?? new Error("verify failed");
                 return null;
             });
-        const lensResults = await mapWithConcurrencyLimit(REVIEW_LENSES, MAX_CONCURRENCY, async (lens) => {
+        const lensResults = await mapWithConcurrencyLimit(reviewers, MAX_CONCURRENCY, async (lens) => {
             // Per-lens lifecycle: each lens child is its own agent on the desktop, so it
             // starts and finishes on its OWN timing rather than the whole fan-out's.
             // The terminal panel ignores lens-tagged signals and paints one review row.
             progress({ kind: "stage_start", stageId: "review", lens, round });
-            const lensResult = await runStageFn({ ...review, lens }, { ticket: promptTicket, previous: reviewInput, lens, grounded }, stageDepsFor({ stageId: "review", lens, round }));
+            const lensResult = await runStageFn({ ...review, lens }, { ticket: promptTicket, previous: reviewInput, lens, grounded }, stageDepsFor({ stageId: "review", lens, round }, undefined, lane.skillsEveryStage));
             progress({ kind: "stage_done", stageId: "review", lens, round });
             return lensResult;
         });
@@ -1115,7 +1245,9 @@ export async function runPipeline(ticket, deps) {
         // which parses to zero findings — the loop would stop a false "clean" while
         // every request was failing. Checked on ALL lens results (not just failed
         // ones) for exactly that reason.
-        const lensCredit = lensResults.map((r) => creditExhaustionReason(r)).find((v) => Boolean(v));
+        const lensCredit = lensResults
+            .map((r) => creditExhaustionReason(r))
+            .find((v) => Boolean(v));
         if (lensCredit) {
             stopReason = "failed";
             log("pipeline_failed", { phase: "review", round, reason: lensCredit });
@@ -1133,13 +1265,22 @@ export async function runPipeline(ticket, deps) {
         const perLens = [];
         for (let i = 0; i < lensResults.length; i++) {
             const r = lensResults[i];
-            const lens = REVIEW_LENSES[i];
+            const lens = reviewers[i];
             if (isFailed(r)) {
                 failedLenses.push(lens);
-                progress({ kind: "stage_done", stageId: "review", lens, round, findings: 0, blocking: 0, degraded: "failed" });
+                progress({
+                    kind: "stage_done",
+                    stageId: "review",
+                    lens,
+                    round,
+                    findings: 0,
+                    blocking: 0,
+                    degraded: "failed",
+                });
                 continue;
             }
-            let parsed = parseFindings(r.finalOutput, lens);
+            // The lane's one reviewer names each finding's lens; a lens fan child is its lens.
+            let parsed = parseFindings(r.finalOutput, lens, { lensColumn: lens === undefined });
             // Visible signal (not silent): a non-empty reviewer output that parses to
             // zero findings is a likely format miss, not a guaranteed clean review.
             if (parsed.length === 0 && r.finalOutput.trim())
@@ -1158,7 +1299,7 @@ export async function runPipeline(ticket, deps) {
                 !deps.signal?.aborted) {
                 const reask = await runStageFn(reaskStage(review), { ticket: promptTicket, previous: r.finalOutput, lens, grounded }, stageDepsFor({ stageId: "review", lens, round }));
                 if (!isFailed(reask))
-                    parsed = parseFindings(reask.finalOutput, lens);
+                    parsed = parseFindings(reask.finalOutput, lens, { lensColumn: lens === undefined });
                 log("review_reask", { lens, findings: parsed.length });
                 if (parsed.length === 0)
                     unparseableLenses.push(lens);
@@ -1195,7 +1336,12 @@ export async function runPipeline(ticket, deps) {
                 // check unrunnable) survives honestly — absent reason clears it.
                 verifyNote = verify.reason;
                 verifyCommand = verify.command;
-                log("verify_done", { round, ok: verify.ok, command: verify.command, findings: verify.findings.length });
+                log("verify_done", {
+                    round,
+                    ok: verify.ok,
+                    command: verify.command,
+                    findings: verify.findings.length,
+                });
             }
             else if (verify.reason) {
                 verifyNote = verify.reason;
@@ -1206,7 +1352,10 @@ export async function runPipeline(ticket, deps) {
         const findings = unionFindings([...perLens, verifyFindings]);
         // Two degradation flavors, one honest list (§3e): a failed lens was skipped
         // outright; an unparseable lens proceeded as zero findings after the re-ask.
-        const degraded = [...failedLenses, ...unparseableLenses.map((l) => `${l} (unparseable)`)];
+        const degraded = [
+            ...failedLenses.map(reviewerName),
+            ...unparseableLenses.map((l) => `${reviewerName(l)} (unparseable)`),
+        ];
         const degradedLenses = degraded.length > 0 ? degraded : undefined;
         rounds.push({ round, lensResults, findings, ...(degradedLenses ? { degradedLenses } : {}) });
         log("review_round", {
@@ -1215,8 +1364,17 @@ export async function runPipeline(ticket, deps) {
             blocking: hasBlockingFindings(findings),
             ...(degradedLenses ? { degradedLenses } : {}),
         });
-        progress({ kind: "findings", round, total: findings.length, blocking: blockingCount(findings) });
-        stageEvent("review", "finish", { round, findings: findings.length, items: roundFindingItems(findings) });
+        progress({
+            kind: "findings",
+            round,
+            total: findings.length,
+            blocking: blockingCount(findings),
+        });
+        stageEvent("review", "finish", {
+            round,
+            findings: findings.length,
+            items: roundFindingItems(findings),
+        });
         // Honest health check BEFORE trusting the verdict: an aborted or crashed
         // review must NOT be read as a clean review (empty output → [] findings →
         // would otherwise stop 'clean'). Mirrors the build half's isFailed guard.
@@ -1231,8 +1389,9 @@ export async function runPipeline(ticket, deps) {
         // the loop cannot proceed without, default: correctness) is the one that
         // failed. Otherwise the surviving lenses carry the round and `degradedLenses`
         // already records the skip honestly.
-        const requiredFailed = failedLenses.filter((l) => REQUIRED_LENSES.includes(l));
-        if (failedLenses.length === REVIEW_LENSES.length || requiredFailed.length > 0) {
+        // A lane's only reviewer (no lens) is required by definition.
+        const requiredFailed = failedLenses.filter((l) => l === undefined || REQUIRED_LENSES.includes(l));
+        if (failedLenses.length === reviewers.length || requiredFailed.length > 0) {
             stopReason = "failed";
             log("pipeline_failed", { phase: "review", round, failedLenses, requiredFailed });
             break;
@@ -1243,7 +1402,7 @@ export async function runPipeline(ticket, deps) {
         observedMs.review = clock() - reviewStartedAt;
         // The verdict first: a clean review is clean and a capped one is capped, even
         // past a ceiling, since neither spends anything more.
-        const decision = shouldStop(findings, round);
+        const decision = shouldStop(findings, round, lane.maxReviewRounds);
         if (decision.stop && decision.reason) {
             stopReason = decision.reason;
             break;
@@ -1253,7 +1412,12 @@ export async function runPipeline(ticket, deps) {
         const overAfterReview = overBudget();
         if (overAfterReview) {
             stopReason = "budget_exceeded";
-            log("pipeline_stop", { reason: "budget_exceeded", phase: "review", round, detail: overAfterReview });
+            log("pipeline_stop", {
+                reason: "budget_exceeded",
+                phase: "review",
+                round,
+                detail: overAfterReview,
+            });
             break;
         }
         // The review's findings are recorded; a fix that cannot finish in time would
@@ -1267,7 +1431,13 @@ export async function runPipeline(ticket, deps) {
         const fixStartedAt = clock();
         progress({ kind: "stage_start", stageId: "fix", round });
         stageEvent("fix", "start", { round });
-        const fixResult = await runStageFn(fix, { ticket: promptTicket, previous: designContext ? `${serializeBlocking(findings)}\n\n${designContext}` : serializeBlocking(findings), grounded }, stageDepsFor({ stageId: "fix", round }, undefined, true));
+        const fixResult = await runStageFn(fix, {
+            ticket: promptTicket,
+            previous: designContext
+                ? `${serializeBlocking(findings)}\n\n${designContext}`
+                : serializeBlocking(findings),
+            grounded,
+        }, stageDepsFor({ stageId: "fix", round }, undefined, true));
         observedMs.fix = clock() - fixStartedAt;
         stages.push(fixResult);
         log("stage_done", { stageId: "fix", exitCode: fixResult.exitCode });
@@ -1285,7 +1455,8 @@ export async function runPipeline(ticket, deps) {
             break;
         }
         if (isFailed(fixResult)) {
-            const why = toolFailureReason(fixResult) ?? (fixResult.errorMessage || fixResult.stderr || "(no output)");
+            const why = toolFailureReason(fixResult) ??
+                (fixResult.errorMessage || fixResult.stderr || "(no output)");
             // Symmetric with the build-half guard: a fix stage KILLED mid-work (timeout /
             // transient abort/error) leaves the run's reviewed diff (implement + any prior
             // accepted rounds) plus a partial fix in the tree. By here the build half has
@@ -1293,7 +1464,9 @@ export async function runPipeline(ticket, deps) {
             // preservable work — report `partial`, not a bare `failed`. A clean exit-0 fix
             // failed only by the R3-a tool-health gate is the silent landmine (edits never
             // landed) and keeps the hard `failed`.
-            const fixKilledMidWork = fixResult.exitCode !== 0 || fixResult.stopReason === "aborted" || fixResult.stopReason === "error";
+            const fixKilledMidWork = fixResult.exitCode !== 0 ||
+                fixResult.stopReason === "aborted" ||
+                fixResult.stopReason === "error";
             if (fixKilledMidWork) {
                 stopReason = "partial";
                 log("pipeline_partial", { phase: "fix", round, reason: why });
@@ -1314,8 +1487,16 @@ export async function runPipeline(ticket, deps) {
         // crash now can resume at the NEXT round against this fix's output. Snapshot
         // the post-fix tree as the resume consistency key.
         const afterFix = await snapshotFn(deps.cwd, deps.signal);
-        reviewInput = designContext ? `${fixResult.finalOutput}\n\n${designContext}` : fixResult.finalOutput;
-        writeCheckpoint(mkRecord("round_done", { round, reviewInput, findings, snapshot: afterFix, usage: currentUsage() }));
+        reviewInput = designContext
+            ? `${fixResult.finalOutput}\n\n${designContext}`
+            : fixResult.finalOutput;
+        writeCheckpoint(mkRecord("round_done", {
+            round,
+            reviewInput,
+            findings,
+            snapshot: afterFix,
+            usage: currentUsage(),
+        }));
         round += 1;
     }
     log("pipeline_stop", { reason: stopReason, round });