@yagni-app/code 0.3.2 → 0.3.3

package/dist/extension/pipeline/personas.js

@@ -9,6 +9,12 @@
  *   - reviewer (business-fit lens): call `review_business_match` and treat a
  *     conflict with a recorded decision as at least High.
  *
+ * The implement diamond adds two more roles: `orchestrator` (the read-only
+ * partitioner, carrying the ```partition output contract `parsePartition` reads)
+ * and `synthesizer` (the seam-reconciler that writes the review handoff). Its
+ * parallel builders reuse the `worker` body plus a per-workstream clause from
+ * {@link builderPersonaClause}.
+ *
  * The reviewer also carries the strict, parseable findings output contract so
  * the `{previous}` handoff into the fix stage parses (see `findings.ts`).
  *
@@ -95,6 +101,66 @@ The reasoning, grounded in what you actually read. Cite files and lines.
 The specific evidence that would flip this. If you were not able to verify something load-bearing, say so here rather than hedging the recommendation.
 
 Be terse and decisive. The caller is mid-task and paying peak rates for your turn.`;
+const ORCHESTRATOR_INTRO = `You are a build orchestrator. You receive an approved implementation plan and decide ONE thing: whether the build can safely be split into parallel workstreams with disjoint file sets, or must run as a single writer. You do not implement anything.`;
+const ORCHESTRATOR_GROUNDING = `You are grounded. Call ask_yagni before inferring a convention, an ownership boundary, or how this company splits work; a partition that cuts across a boundary this company treats as one surface is a bad partition even when the file sets look clean.`;
+const ORCHESTRATOR_RULES = `You are READ-ONLY. You have read, grep, find, ls and read-only bash. Do not write, edit, build, or run anything that changes the tree: the builders you partition for do the work.
+
+Your bias is CONSERVATIVE. Parallel writers earn their width; they do not get it by default. Fan ONLY when the plan splits into obviously clean surfaces whose file sets do not touch. When in doubt, when the plan is one cluster of coupled edits, when the repo context you were given is thin, or when you cannot name each workstream's files with confidence, return single-writer with the reason. A single-writer verdict is a good answer, not a failure; a guessed partition is the one outcome that is worse than running serially.
+
+How to judge:
+1. Read the plan's own "Files to modify / create" list first; it is the strongest evidence you have.
+2. Group the work by surface (package, layer, directory), not by plan step ordering.
+3. Check the groups for shared files, shared types, and edits that must land together. Any of those means fewer workstreams, or one.
+4. Give each workstream a tier: "efficient" for mechanical work (test fixture updates, renames, copy sweeps, mechanical follow-through), "standard" for load-bearing work that carries judgment. This is cost fitting, not perspective: never split the same work across two workstreams.`;
+/**
+ * The machine-readable partition contract the orchestrator must emit, kept in
+ * lockstep with `parsePartition` (`fanout.ts`). Separate from the body so the
+ * contract text has one home and the tests can read it directly.
+ */
+const PARTITION_CONTRACT = `=== Partition output contract (required) ===
+End your answer with a fenced block in EXACTLY this form and nothing after it:
+
+\`\`\`partition
+{
+  "mode": "fan",
+  "width": 2,
+  "reason": "why this width, in one sentence",
+  "workstreams": [
+    { "name": "backend-routes", "task": "what this builder does", "files": ["packages/backend/src/routes"], "tier": "standard" }
+  ]
+}
+\`\`\`
+
+Rules the parser enforces, so getting them wrong wastes the run:
+- "mode" is "fan" or "single". A single-writer verdict is just {"mode": "single", "reason": "..."} with no width and no workstreams.
+- "width" is 2, 4 or 8, and equals the number of workstreams.
+- "reason" is always required, on both modes.
+- Every workstream needs a name, a task, and at least one file claim.
+- A file claim is a path PREFIX from the repo root: a directory claims its whole subtree. Claim the DIRECTORIES of any files a workstream will create, so a planned new file is not an out-of-claim edit.
+- Claims must be pairwise DISJOINT across workstreams, nesting included: claiming a directory in one workstream and a file inside it in another is an overlap and fails the run.
+- "tier" is "standard" (default) or "efficient".`;
+const SYNTHESIZER_INTRO = `You are a synthesizer. Several builders just worked in parallel in this ONE shared working tree, each pinned to its own files. Their diffs are already in place: you are not applying patches, you are reconciling the seams between them and writing the single handoff the reviewers will read.`;
+const SYNTHESIZER_GROUNDING = `You are grounded. Call ask_yagni before guessing about anything organization- or codebase-specific, and call record_decision for any product-intent call you are forced to make while reconciling.`;
+const SYNTHESIZER_RULES = `What to reconcile:
+1. Seams between workstreams: imports that do not line up, a shared type each builder assumed differently, duplicated helpers, a call site left on the old signature.
+2. The checker's findings, which are deterministic and name real files.
+3. Any out-of-claim edits reported to you, plus anything a builder flagged as needing a change outside its claims.
+
+Make the minimal edits that make the union coherent. Do not re-litigate a builder's approach, do not refactor beyond the seams, and do not run git add, git commit, or git stash; committing is the finish stage's job.
+
+Output:
+## Completed
+The change as ONE piece of work, not a list of builders.
+## Files changed
+- \`path\` - what changed
+## Seams reconciled
+What did not line up between workstreams, and what you did about it.
+## Open findings
+Anything the checker or a builder reported that is still not fixed, named honestly so the reviewers can pick it up. Say "none" when there are none.
+## Notes
+Anything the reviewer should know (exact file paths, key functions touched).`;
+const ORCHESTRATOR_BODY = [ORCHESTRATOR_INTRO, ORCHESTRATOR_GROUNDING, ORCHESTRATOR_RULES].join("\n\n");
+const SYNTHESIZER_BODY = [SYNTHESIZER_INTRO, SYNTHESIZER_GROUNDING, SYNTHESIZER_RULES].join("\n\n");
 const GUARDIAN_BODY = `You are a safety reviewer. You review shell commands before they run and decide one of three outcomes: allow, ask, or deny. You may read files for context (a script the command runs, a config it touches) but you never write or execute anything. Your final output is ONLY a JSON verdict — no prose around it.
 
 Risk taxonomy:
@@ -126,6 +192,8 @@ export const PERSONA_BODIES = {
     reviewer: REVIEWER_BODY,
     advisor: ADVISOR_BODY,
     guardian: GUARDIAN_BODY,
+    orchestrator: [ORCHESTRATOR_BODY, PARTITION_CONTRACT].join("\n\n"),
+    synthesizer: SYNTHESIZER_BODY,
 };
 /**
  * Grounding-FREE persona bodies for the M6 grounded-vs-blind eval ONLY. These are
@@ -217,6 +285,11 @@ export const BLIND_PERSONA_BODIES = {
     reviewer: REVIEWER_BLIND,
     advisor: ADVISOR_BLIND,
     guardian: GUARDIAN_BODY,
+    // The diamond's own agents: same roles with the grounding paragraph dropped.
+    // No eval lane fans implement today, but `personaBody` throws on an unknown
+    // agent, so a missing twin would be a crash rather than a degraded measurement.
+    orchestrator: [ORCHESTRATOR_INTRO, ORCHESTRATOR_RULES, PARTITION_CONTRACT].join("\n\n"),
+    synthesizer: [SYNTHESIZER_INTRO, SYNTHESIZER_RULES].join("\n\n"),
 };
 /** The lens-specific clause appended to the reviewer body, one per review angle. */
 const LENS_CLAUSES = {
@@ -249,10 +322,45 @@ const BLIND_LENS_CLAUSES = {
     business_fit: "Lens: BUSINESS-FIT. Does this change match the apparent product intent and the conventions visible in the code? Right code doing the wrong thing is exactly the failure you exist to catch. A clear mismatch is at least High.",
     does_it_hold: LENS_CLAUSES.does_it_hold,
 };
+/**
+ * The shared-worktree discipline every fan-out builder runs under. All builders
+ * edit the SAME tree concurrently (there are no per-child worktrees), so the
+ * rules that keep them out of each other's way are prompt discipline: stay
+ * inside your claims, never touch the git index (parallel index writes race on
+ * index.lock, and committing is FINISH's job anyway), and leave test execution
+ * to the deterministic checker that runs on the merged tree.
+ */
+const SHARED_TREE_RULES = `Shared working tree rules:
+- Never run a git index operation: no git add, no git commit, no git stash, no git checkout, no git reset. Other builders may be writing this same tree right now, and committing is the finish stage's job.
+- Do not run the repo's full test suite. A deterministic checker runs typecheck and the repo's own tests on the merged result after the fan; your job is the code.`;
+/**
+ * The per-workstream clause appended to a fan-out builder's (or fixer's) persona:
+ * the files it owns, what its siblings own, and the shared-tree discipline. With
+ * no workstream (the single-writer path, including its fix turns) only the
+ * shared-tree rules apply, since there is nothing to pin against.
+ */
+export function builderPersonaClause(workstream, siblings = []) {
+    if (!workstream)
+        return SHARED_TREE_RULES;
+    const parts = [
+        `You are building ONE workstream of a plan that was split across parallel builders: "${workstream.name}".`,
+        ["Files you own (path prefixes; a directory covers its whole subtree):", ...workstream.files.map((f) => `- ${f}`)].join("\n"),
+        "Create new files only inside the paths you own. Edit nothing outside them.",
+    ];
+    if (siblings.length > 0) {
+        parts.push([
+            "Other builders are working in this same tree right now. Their files, so you know where the seams are (read them if you need to, never edit them):",
+            ...siblings.map((s) => `- ${s.name}: ${s.files.join(", ")}`),
+        ].join("\n"));
+    }
+    parts.push("If your workstream genuinely needs a change outside the paths you own, do NOT make it. Name the file and the change in your Notes so the synthesizer reconciles that seam.", SHARED_TREE_RULES);
+    return parts.join("\n\n");
+}
 /**
  * Resolve the system-prompt body for a stage. For non-review stages this is the
  * role body; for the review stage it appends the lens-specific clause and the
- * required findings output contract so the reviewer's output parses.
+ * required findings output contract so the reviewer's output parses. A stage
+ * carrying a `personaClause` (the fan-out builders) gets it appended last.
  *
  * `grounded` defaults true (every real /go stage). The M6 eval passes
  * `grounded: false` to select the grounding-free bodies + lens clauses for the
@@ -264,10 +372,13 @@ export function personaBody(stage, opts = {}) {
     const base = bodies[stage.agent];
     if (!base)
         throw new Error(`No persona body for agent "${stage.agent}"`);
-    if (stage.id !== "review")
-        return base;
-    const lens = stage.lens ?? "correctness";
-    const clause = (grounded ? LENS_CLAUSES : BLIND_LENS_CLAUSES)[lens];
-    return [base, clause, FINDINGS_CONTRACT].join("\n\n");
+    const parts = [base];
+    if (stage.id === "review") {
+        const lens = stage.lens ?? "correctness";
+        parts.push((grounded ? LENS_CLAUSES : BLIND_LENS_CLAUSES)[lens], FINDINGS_CONTRACT);
+    }
+    if (stage.personaClause?.trim())
+        parts.push(stage.personaClause.trim());
+    return parts.join("\n\n");
 }
 //# sourceMappingURL=personas.js.map

package/dist/extension/pipeline/runSession.d.ts

@@ -89,12 +89,56 @@ export interface StartArgs {
     repo?: string;
     branch?: string;
 }
-/** A pipeline stage boundary event. */
+/**
+ * The implement diamond's partition verdict as the run records it: the fan and
+ * its width, or the single-writer degrade, always with the reason that produced
+ * it. Rides one implement stage beat (see {@link StageArgs}).
+ */
+export interface StageFanoutDecision {
+    mode: "fan" | "single";
+    width?: number;
+    reason: string;
+}
+/**
+ * One fan-out child on a stage beat: the workstream's name, the tier it runs on,
+ * how many paths it claimed, and the state the run has actually OBSERVED. There
+ * is no "pending" state on purpose: a child appears the moment it starts, so a
+ * surface can only ever paint children that really ran.
+ */
+export interface StageChildRow {
+    name: string;
+    tier?: "standard" | "efficient";
+    state: "running" | "done" | "failed";
+    /** How many path claims the partition gave this workstream; absent when unrecorded. */
+    files?: number;
+    note?: string;
+}
+/** One bounded fix turn: which findings it answered and which children it re-engaged. */
+export interface StageFixTurn {
+    turn: number;
+    findings: number;
+    reengaged: string[];
+}
+/**
+ * A pipeline stage boundary event.
+ *
+ * `fanout` / `children` / `fixTurns` are the implement diamond's additive
+ * payloads (spec "Recording and the run surface"). They ride INTERIM implement
+ * beats and are append-only: an older CLI simply never sends them, and a backend
+ * that does not know them ignores them, so the contract stays backwards
+ * compatible in both directions. Every beat carries at most one of them.
+ */
 export interface StageArgs {
     stage: string;
     phase: "start" | "finish";
     round?: number;
     findings?: number;
+    /** The diamond's verdict, sent once per implement stage the moment it resolves. */
+    fanout?: StageFanoutDecision;
+    /** The whole per-workstream roster, re-sent on every child state change. */
+    children?: StageChildRow[];
+    /** Every fix turn recorded so far, re-sent as each new one lands. */
+    fixTurns?: StageFixTurn[];
 }
 /** An in-loop correction captured during the run. */
 export interface CorrectionArgs {

package/dist/extension/pipeline/runState.d.ts

@@ -23,6 +23,7 @@
  *     the panel's cross-lens interleaving is preserved by code that never moved.
  */
 import type { ActivityLine, FeedStageId, JsonEvent, PipelineProgress, ReviewLens, StageTag, StopReason } from "./types.js";
+import type { PartitionWidth } from "./fanout.js";
 /** The fixed stage order shown by both surfaces (v1 stages + the post-loop FINISH row). */
 export declare const STAGE_ORDER: FeedStageId[];
 /**
@@ -48,11 +49,18 @@ export interface AgentUsage {
 export interface AgentNode {
     /**
      * Stable across paints: the stage id, `review:<lens>:r<round>` for a lens
-     * child, or `fix:r<round>` for a per-round fix execution.
+     * child, `implement:<workstream>` for a fan-out builder, or `fix:r<round>` for
+     * a per-round fix execution.
      */
     id: string;
     stageId: FeedStageId;
     lens?: ReviewLens;
+    /**
+     * Which fan-out child of the implement diamond this node is (the direct
+     * analogue of `lens`). A re-engaged builder keeps its node across fix turns, so
+     * one workstream is one row for the whole stage.
+     */
+    workstream?: string;
     round?: number;
     status: AgentStatus;
     summary: string;
@@ -80,6 +88,18 @@ export interface RoundTally {
  * no pids, no absolute paths — so it stays portable to a non-local executor at
  * zero cost. The tab does not need them.
  */
+/** The implement diamond's recorded verdict, as the desktop reads it. */
+export interface FanoutRecord {
+    mode: "fan" | "single";
+    width?: PartitionWidth;
+    reason: string;
+}
+/** One recorded fix turn of the implement diamond. */
+export interface FixTurnRecord {
+    turn: number;
+    findings: number;
+    reengaged: string[];
+}
 export interface GoRunState {
     v: 1;
     runId: string;
@@ -103,16 +123,26 @@ export interface GoRunState {
      * `UNTRACKED_NOTICE` in goCommand.ts): there is no server id to give it.
      */
     serverRunId?: string;
+    /**
+     * How the implement stage resolved to build (the diamond's partition verdict,
+     * or its recorded single-writer degrade). Absent on a run whose implement stage
+     * never reported one, so an older run reads exactly as it did before.
+     */
+    fanout?: FanoutRecord;
+    /** The diamond's bounded fix turns, in order. Absent when none ran. */
+    fixTurns?: FixTurnRecord[];
 }
 /**
- * Stable agent id: a lens child is keyed by its lens AND round, and fix — the
- * only lens-less stage that re-executes per round — by its round, so each
- * round's fix keeps its own clock and usage instead of accumulating tokens on a
- * timer that resets (the "181k tok in 59s" artifact). Review stage-level events
- * stay on the bare `review` node: they mark the round boundary, and the lens
- * children carry the round's real work.
+ * Stable agent id: a lens child is keyed by its lens AND round, a fan-out builder
+ * by its workstream, and fix — the only lens-less stage that re-executes per
+ * round — by its round, so each round's fix keeps its own clock and usage instead
+ * of accumulating tokens on a timer that resets (the "181k tok in 59s" artifact).
+ * Review stage-level events stay on the bare `review` node: they mark the round
+ * boundary, and the lens children carry the round's real work. The implement
+ * diamond behaves the same way: the bare `implement` node is the stage boundary,
+ * and the workstream children carry the parallel build.
  */
-export declare function agentId(stageId: FeedStageId, lens?: ReviewLens, round?: number): string;
+export declare function agentId(stageId: FeedStageId, lens?: ReviewLens, round?: number, workstream?: string): string;
 export interface RunStateInit {
     runId: string;
     ticket: string;
@@ -130,14 +160,18 @@ export declare class RunState {
     private findingsBlocking;
     private readonly rounds;
     private readonly agents;
+    private fanout;
+    private readonly fixTurns;
+    /** Width the partition asked for; the children themselves are the honest denominator. */
+    private fanoutWidth;
     constructor(init: RunStateInit);
     /** The lens-less stage agent, or undefined for an unknown stage. */
     private stageAgent;
     /**
-     * The agent for a tag, created on demand. Lens children are inserted directly
-     * after their parent stage and any existing siblings, so the array order still
-     * reads top-to-bottom for the desktop and the lens-less filter still yields
-     * STAGE_ORDER for the terminal.
+     * The agent for a tag, created on demand. Lens and workstream children are
+     * inserted directly after their parent stage and any existing siblings, so the
+     * array order still reads top-to-bottom for the desktop and the child-less
+     * filter still yields STAGE_ORDER for the terminal.
      */
     private ensureAgent;
     /** Fold a structured progress signal. `at` is only read by the desktop surface. */
@@ -165,6 +199,17 @@ export declare class RunState {
      * not a stale bare placeholder.
      */
     stageAgents(): AgentNode[];
+    /**
+     * The implement diamond's compact row summary for the terminal: how the stage
+     * resolved to build, how many children it fanned into, and how many of them
+     * have finished (a failed child is finished too). Undefined until the stage
+     * reports a verdict, so a run that never fanned renders exactly as before.
+     */
+    fanoutRow(): {
+        mode: "fan" | "single";
+        total: number;
+        done: number;
+    } | undefined;
     header(): {
         ticket: string;
         round: number;

package/dist/extension/pipeline/runState.js

@@ -34,16 +34,20 @@ function emptyUsage() {
     return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
 /**
- * Stable agent id: a lens child is keyed by its lens AND round, and fix — the
- * only lens-less stage that re-executes per round — by its round, so each
- * round's fix keeps its own clock and usage instead of accumulating tokens on a
- * timer that resets (the "181k tok in 59s" artifact). Review stage-level events
- * stay on the bare `review` node: they mark the round boundary, and the lens
- * children carry the round's real work.
+ * Stable agent id: a lens child is keyed by its lens AND round, a fan-out builder
+ * by its workstream, and fix — the only lens-less stage that re-executes per
+ * round — by its round, so each round's fix keeps its own clock and usage instead
+ * of accumulating tokens on a timer that resets (the "181k tok in 59s" artifact).
+ * Review stage-level events stay on the bare `review` node: they mark the round
+ * boundary, and the lens children carry the round's real work. The implement
+ * diamond behaves the same way: the bare `implement` node is the stage boundary,
+ * and the workstream children carry the parallel build.
  */
-export function agentId(stageId, lens, round) {
+export function agentId(stageId, lens, round, workstream) {
     if (lens)
         return `${stageId}:${lens}:r${round ?? 1}`;
+    if (workstream)
+        return `${stageId}:${workstream}`;
     if (stageId === "fix" && round !== undefined)
         return `fix:r${round}`;
     return stageId;
@@ -60,6 +64,10 @@ export class RunState {
     findingsBlocking = 0;
     rounds = [];
     agents;
+    fanout;
+    fixTurns = [];
+    /** Width the partition asked for; the children themselves are the honest denominator. */
+    fanoutWidth;
     constructor(init) {
         this.runId = init.runId;
         this.ticket = init.ticket;
@@ -78,13 +86,14 @@ export class RunState {
         return this.agents.find((a) => a.id === stageId);
     }
     /**
-     * The agent for a tag, created on demand. Lens children are inserted directly
-     * after their parent stage and any existing siblings, so the array order still
-     * reads top-to-bottom for the desktop and the lens-less filter still yields
-     * STAGE_ORDER for the terminal.
+     * The agent for a tag, created on demand. Lens and workstream children are
+     * inserted directly after their parent stage and any existing siblings, so the
+     * array order still reads top-to-bottom for the desktop and the child-less
+     * filter still yields STAGE_ORDER for the terminal.
      */
-    ensureAgent(stageId, lens, round, at) {
-        const id = agentId(stageId, lens, round);
+    ensureAgent(tag, at) {
+        const { stageId, lens, round, workstream } = tag;
+        const id = agentId(stageId, lens, round, workstream);
         const found = this.agents.find((a) => a.id === id);
         if (found)
             return found;
@@ -92,6 +101,7 @@ export class RunState {
             id,
             stageId,
             ...(lens ? { lens } : {}),
+            ...(workstream ? { workstream } : {}),
             ...(round !== undefined ? { round } : {}),
             status: "active",
             summary: "",
@@ -122,7 +132,7 @@ export class RunState {
                 // own child; a bare stage signal (including review's round boundary,
                 // which must return to active even though a prior round left it done)
                 // lands on the pre-seeded stage node.
-                const target = this.ensureAgent(p.stageId, p.lens, p.round, at);
+                const target = this.ensureAgent(p, at);
                 target.status = "active";
                 target.startedAt = at;
                 // `delete`, not `= undefined`: an explicitly-undefined property still
@@ -133,7 +143,7 @@ export class RunState {
             case "stage_done": {
                 if (typeof p.round === "number")
                     this.round = p.round;
-                const target = this.ensureAgent(p.stageId, p.lens, p.round, at);
+                const target = this.ensureAgent(p, at);
                 if (p.degraded === "failed") {
                     target.status = "failed";
                 }
@@ -149,6 +159,19 @@ export class RunState {
                     target.degraded = p.degraded;
                 break;
             }
+            case "fanout": {
+                this.fanout = {
+                    mode: p.mode,
+                    ...(p.width ? { width: p.width } : {}),
+                    reason: p.reason,
+                };
+                this.fanoutWidth = p.width ?? p.workstreams?.length;
+                break;
+            }
+            case "fix_turn": {
+                this.fixTurns.push({ turn: p.turn, findings: p.findings, reengaged: [...p.reengaged] });
+                break;
+            }
             case "findings": {
                 this.round = p.round;
                 this.findingsTotal = p.total;
@@ -181,7 +204,7 @@ export class RunState {
      * actions ride BOTH the agent's own list and the terminal's flat ring buffer.
      */
     applyLine(line, tag, at = 0) {
-        const target = this.ensureAgent(tag.stageId, tag.lens, tag.round, at);
+        const target = this.ensureAgent(tag, at);
         if (line.kind === "narration") {
             target.summary = line.text;
             return;
@@ -207,7 +230,7 @@ export class RunState {
     applyUsage(ev, tag, at = 0) {
         if (ev.type !== "message_end" || ev.message?.role !== "assistant")
             return;
-        const target = this.ensureAgent(tag.stageId, tag.lens, tag.round, at);
+        const target = this.ensureAgent(tag, at);
         target.usage.turns += 1;
         const u = ev.message.usage;
         if (!u)
@@ -240,11 +263,28 @@ export class RunState {
      */
     stageAgents() {
         return STAGE_ORDER.flatMap((id) => {
-            const perRound = this.agents.filter((a) => a.stageId === id && a.lens === undefined && a.id !== id);
+            const perRound = this.agents.filter((a) => a.stageId === id && a.lens === undefined && a.workstream === undefined && a.id !== id);
             const row = perRound[perRound.length - 1] ?? this.stageAgent(id);
             return row ? [row] : [];
         });
     }
+    /**
+     * The implement diamond's compact row summary for the terminal: how the stage
+     * resolved to build, how many children it fanned into, and how many of them
+     * have finished (a failed child is finished too). Undefined until the stage
+     * reports a verdict, so a run that never fanned renders exactly as before.
+     */
+    fanoutRow() {
+        if (!this.fanout)
+            return undefined;
+        const children = this.agents.filter((a) => a.workstream !== undefined);
+        const done = children.filter((a) => a.status === "done" || a.status === "failed").length;
+        return {
+            mode: this.fanout.mode,
+            total: this.fanoutWidth ?? children.length,
+            done,
+        };
+    }
     header() {
         return {
             ticket: this.ticket,
@@ -269,6 +309,8 @@ export class RunState {
             ...(this.stopReason ? { stopReason: this.stopReason } : {}),
             agents: this.agents,
             ...(this.serverRunId !== undefined ? { serverRunId: this.serverRunId } : {}),
+            ...(this.fanout ? { fanout: this.fanout } : {}),
+            ...(this.fixTurns.length > 0 ? { fixTurns: this.fixTurns } : {}),
         };
     }
 }

package/dist/extension/pipeline/runner.js

@@ -27,6 +27,7 @@ import { trackChild } from "./childRegistry.js";
 import { finalOutputFrom, foldEvent, newEventAccumulator } from "./events.js";
 import { buildStageInvocation, groundedChildArgv } from "./invocation.js";
 import { personaBody } from "./personas.js";
+import { clampTier, resolveTierCap } from "./tierCap.js";
 import { PER_TASK_OUTPUT_CAP, } from "./types.js";
 /**
  * Default per-line stdout ceiling (16 MiB). A legitimate NDJSON event — even one
@@ -85,6 +86,12 @@ export async function runStage(stage, ctx, deps) {
     const spawnFn = deps.spawn ?? nodeSpawn;
     const writePrompt = deps.writePrompt ?? defaultWritePrompt;
     const resolveChild = deps.resolveChild ?? defaultResolveChild;
+    // The run's tier ceiling (`YAGNI_GO_TIER_CAP`), resolved ONCE here — the
+    // single seam every stage, review lens, format re-ask and subagent child
+    // passes through. Absent on a normal run, so tiers stay the pipeline's own.
+    const envForCap = deps.env ?? process.env;
+    const tierCap = resolveTierCap(envForCap);
+    const effectiveTier = clampTier(stage.model, tierCap);
     const personaStage = ctx.lens ? { ...stage, lens: ctx.lens } : stage;
     // grounded defaults true; only the M6 blind eval lane passes grounded: false.
     const body = (deps.personaBody ?? personaBody)(personaStage, { grounded: ctx.grounded !== false });
@@ -92,6 +99,7 @@ export async function runStage(stage, ctx, deps) {
     const result = {
         stageId: stage.id,
         agent: stage.agent,
+        tier: effectiveTier,
         exitCode: 0,
         finalOutput: "",
         usage: { ...EMPTY_USAGE },
@@ -105,6 +113,7 @@ export async function runStage(stage, ctx, deps) {
             previous: ctx.previous,
             promptFilePath: filePath,
             lens: ctx.lens,
+            ...(tierCap ? { tierCap } : {}),
         });
         const { piCli, extensionPath } = resolveChild();
         const argv = groundedChildArgv(passthrough, { piCli, extensionPath });
@@ -141,7 +150,7 @@ export async function runStage(stage, ctx, deps) {
         // to the session id alone.
         const callerLabel = deps.callerLabel ?? (ctx.lens ? `go:${stage.id}:${ctx.lens}` : `go:${stage.id}`);
         const childEnv = {
-            ...(deps.env ?? process.env),
+            ...envForCap,
             YAGNI_CALLER: callerLabel,
             ...(deps.attribution?.runId ? { YAGNI_RUN_ID: deps.attribution.runId } : {}),
         };

package/dist/extension/pipeline/stages.d.ts

@@ -18,7 +18,15 @@
  *
  * `selectStages(lane)` returns the full list for v1 and is the seam where v2
  * complexity-lanes plug in without a rewrite.
+ *
+ * The implement stage additionally derives a DIAMOND from this same data:
+ * `orchestratorStage` (peak partitioner) → `builderStage` per workstream (the
+ * implement def at the workstream's own tier) → `synthesizerStage` (seam
+ * reconciler) → `fixerStage` for the bounded fix turns. Every one of them keeps
+ * `id: "implement"`, so `StageId` never widens and the feed, the five-stage
+ * rail, and the tier cap treat the whole diamond as today's single stage.
  */
+import type { PartitionWorkstream } from "./fanout.js";
 import type { PipelineStage, ReviewLens } from "./types.js";
 /** The three adversarial review angles, fanned out per round (spec §3). */
 export declare const REVIEW_LENSES: ReviewLens[];
@@ -41,13 +49,82 @@ export declare function reviewStage(): PipelineStage;
  */
 export declare function selectStages(_lane?: "full"): PipelineStage[];
 /**
- * The findings-contract re-ask stage (spec §3e): when a HEALTHY lens returns
- * non-empty prose with no ```findings fence, the orchestrator re-invokes it
- * ONCE on the cheap `efficient` tier with this minimal prompt — a pure
- * format-recovery pass, not a second review. The lens's original output rides
- * in as `{previous}`. Tools are the minimal REAL list `["read"]`:
- * `buildStageInvocation` joins `--tools` with a comma, so an empty array would
- * emit the broken `--tools ""`.
+ * The partitioner's caller label. Deliberately a `go:*` caller and never
+ * `subagent:*`: the server clamps `subagent:*` callers to `advanced`, which would
+ * silently downgrade the one peak judgment call in the whole implement stage.
+ */
+export declare const PARTITION_CALLER_LABEL = "go:implement:partition";
+/**
+ * The per-builder caller label, mirroring review's `go:review:<lens>` so
+ * `GET /spend?runId=` attributes the fan per workstream for free. Workstream
+ * names come from a model, so the segment is sanitized into the proxy's caller
+ * charset and the whole label is kept inside its 64-char cap.
+ */
+export declare function workstreamCallerLabel(name: string): string;
+/**
+ * The repo context handed to the partitioner. BOTH fields are optional by
+ * contract: an interactive /go has the map stage's brief, a mission run (which
+ * skips map and plan) has the injected scoping memo, and a run may have neither.
+ * Thin context is not a problem to paper over — it is exactly the case where the
+ * conservative bias says single-writer.
+ */
+export interface PartitionContext {
+    /** The map stage's compressed repo brief, when the map stage ran. */
+    repoBrief?: string;
+    /** Mission mode: the cached scoping memo that stands in for the map brief. */
+    missionMemo?: string;
+    /**
+     * `go.fanout = "always"` (benchmark / eval lanes): the run is pinned to the
+     * diamond, so the conservative tie-break flips to fanning. It is a bias, not a
+     * command — an honestly unsplittable plan still comes back single-writer,
+     * because a guessed partition is the one thing this contract refuses.
+     */
+    pinned?: boolean;
+}
+/**
+ * The peak-tier partitioner (spec "Partition contract"): reads the approved plan
+ * plus whatever repo context this run actually has and returns a ```partition
+ * block. It runs INSIDE the implement boundary (`id: "implement"`), so the feed,
+ * the five-stage rail, and the tier cap all keep working unchanged.
+ */
+export declare function orchestratorStage(ctx?: PartitionContext): PipelineStage;
+/**
+ * One parallel builder: the implement stage re-entered at the workstream's
+ * assigned tier, tagged with its workstream, and pinned by a persona clause to
+ * the files it claimed (siblings' claims ride along so the seams stay aligned).
+ */
+export declare function builderStage(workstream: PartitionWorkstream, siblings?: PartitionWorkstream[]): PipelineStage;
+/**
+ * The seam-reconciler (spec decision 5). Not a patch applier: with one shared
+ * worktree the union diff is already in place, so this child fixes what does not
+ * line up between builders and writes the implement handoff the review loop reads.
+ */
+export declare function synthesizerStage(): PipelineStage;
+/**
+ * The synthesizer's caller label, in the same `go:implement:*` family as the
+ * partitioner and the builders, so `GET /spend?runId=` attributes the reconciler's
+ * own spend rather than folding it into the anonymous implement default.
+ */
+export declare const SYNTHESIZER_CALLER_LABEL = "go:implement:synthesizer";
+/**
+ * The synthesizer re-engaged inside a fix turn (spec decision 7): findings the
+ * checker could not attribute to any one workstream's claims are seam work, which
+ * is precisely this child's job. It re-writes the implement summary afterwards, so
+ * its output remains the handoff the review loop reads.
+ */
+export declare function synthesizerFixStage(findings: string): PipelineStage;
+/**
+ * A bounded fix turn (spec decision 7): the builder re-entered at its ORIGINAL
+ * tier with the verify findings scoped to its claims. `workstream` is absent on
+ * the single-writer path, where the one builder is re-engaged the same way.
+ */
+export declare function fixerStage(workstream: PartitionWorkstream | undefined, findings: string, siblings?: PartitionWorkstream[]): PipelineStage;
+/**
+ * The partition-contract re-ask: the same cheap format-recovery pass the review
+ * lenses get (`reaskStage`), pointed at the ```partition block instead of
+ * ```findings. One attempt only — a partitioner that still will not emit a
+ * readable block degrades to single-writer, never to a guessed partition.
  */
+export declare function partitionReaskStage(orchestrator: PipelineStage): PipelineStage;
 export declare function reaskStage(review: PipelineStage): PipelineStage;
 //# sourceMappingURL=stages.d.ts.map