@yagni-app/code 0.3.2 → 0.3.4

package/dist/extension/pipeline/stages.js

@@ -18,7 +18,16 @@
  *
  * `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 { sanitizeCallerSegment } from "../config.js";
+import { builderPersonaClause } from "./personas.js";
 /** The three adversarial review angles, fanned out per round (spec §3). */
 export const REVIEW_LENSES = ["correctness", "business_fit", "does_it_hold"];
 /**
@@ -104,6 +113,163 @@ export function selectStages(_lane = "full") {
  * `buildStageInvocation` joins `--tools` with a comma, so an empty array would
  * emit the broken `--tools ""`.
  */
+/** The single implement stage the diamond re-enters per builder / fixer. */
+function implementStage() {
+    const stage = PIPELINE_V1.find((s) => s.id === "implement");
+    if (!stage)
+        throw new Error("PIPELINE_V1 is missing the implement stage");
+    return stage;
+}
+/**
+ * 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 const PARTITION_CALLER_LABEL = "go:implement:partition";
+const IMPLEMENT_CALLER_PREFIX = "go:implement:";
+/**
+ * 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 function workstreamCallerLabel(name) {
+    return `${IMPLEMENT_CALLER_PREFIX}${sanitizeCallerSegment(name, 64 - IMPLEMENT_CALLER_PREFIX.length)}`;
+}
+function repoContextSection(ctx) {
+    const brief = ctx.repoBrief?.trim();
+    const memo = ctx.missionMemo?.trim();
+    const sections = [];
+    if (brief)
+        sections.push(`Repo map (from this run's map stage):\n${brief}`);
+    if (memo) {
+        sections.push("Repo context (cached scoping memo; this run entered at implement, so no map stage ran):\n" + memo);
+    }
+    if (sections.length > 0)
+        return sections.join("\n\n");
+    return ("Repo context: none. No map brief and no scoping memo was available for this run, " +
+        "so the plan is all you have. Thin context is exactly the case where you return " +
+        "single-writer: do not guess a partition.");
+}
+/**
+ * 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 function orchestratorStage(ctx = {}) {
+    return {
+        id: "implement",
+        agent: "orchestrator",
+        model: "peak",
+        tools: [...READ_TOOLS, "ask_yagni"],
+        taskTemplate: "Decide how this approved plan should be built: fanned into parallel workstreams " +
+            "with disjoint file claims, or by a single writer.\n\n" +
+            "Ticket: {ticket}\n\n" +
+            "Approved plan:\n{previous}\n\n" +
+            `${repoContextSection(ctx)}\n\n` +
+            "Rules for this call:\n" +
+            (ctx.pinned
+                ? "- This run is pinned to fan mode: split the plan when it can honestly be split, and " +
+                    "return single-writer only when the work genuinely cannot be divided into disjoint " +
+                    "file sets. Never invent a split to satisfy the pin.\n"
+                : "- The bias is conservative: fan only when the plan splits into obviously clean, " +
+                    "non-touching surfaces. When in doubt, return single-writer with the reason.\n") +
+            "- Legal widths are 2, 4 or 8, and the width must equal the number of workstreams.\n" +
+            "- Every workstream claims the paths it will touch, including the directories of any " +
+            "files it will create. Claims are prefixes and must be pairwise disjoint; an overlap " +
+            "fails the run.\n" +
+            "- Give each workstream a tier: efficient for mechanical work, standard for " +
+            "load-bearing work.\n" +
+            "- End with the ```partition block and nothing after it.",
+    };
+}
+/**
+ * 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 function builderStage(workstream, siblings = []) {
+    const implement = implementStage();
+    return {
+        ...implement,
+        model: workstream.tier,
+        workstream: workstream.name,
+        personaClause: builderPersonaClause(workstream, siblings),
+        taskTemplate: `Implement ONLY your workstream of the plan below: "${workstream.name}".\n\n` +
+            `Your workstream: ${workstream.task}\n\n` +
+            "Write the code against the plan, staying inside the files you own, and call " +
+            "record_decision for any product-intent call you are forced to make.\n\n" +
+            "Plan:\n{previous}",
+    };
+}
+/**
+ * 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 function synthesizerStage() {
+    const implement = implementStage();
+    return {
+        ...implement,
+        agent: "synthesizer",
+        model: "standard",
+        taskTemplate: "Several builders just finished in parallel in this working tree. Reconcile the " +
+            "seams between their changes, address the checker findings and any out-of-claim " +
+            "edits below, and write ONE implement summary for the reviewers.\n\n{previous}",
+    };
+}
+/**
+ * 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 const SYNTHESIZER_CALLER_LABEL = `${IMPLEMENT_CALLER_PREFIX}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 function synthesizerFixStage(findings) {
+    return {
+        ...synthesizerStage(),
+        taskTemplate: "Verification failed on the merged tree, and these findings do not sit inside any single " +
+            "workstream's files, so they are yours. Fix ONLY what is listed, then re-write the implement " +
+            `summary for the reviewers in the same format.\n\nFindings:\n${findings}`,
+    };
+}
+/**
+ * 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 function fixerStage(workstream, findings, siblings = []) {
+    const base = workstream ? builderStage(workstream, siblings) : implementStage();
+    return {
+        ...base,
+        personaClause: builderPersonaClause(workstream, siblings),
+        taskTemplate: "Verification failed. Fix ONLY the findings below" +
+            (workstream ? `, and only inside the files your workstream owns` : "") +
+            ". Do not start a fresh pass over the plan and do not fix anything that is not " +
+            `listed.\n\nFindings:\n${findings}`,
+    };
+}
+/**
+ * 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 function partitionReaskStage(orchestrator) {
+    return {
+        ...orchestrator,
+        model: "efficient",
+        tools: ["read"],
+        taskTemplate: "Re-emit ONLY the ```partition block for the decision you just made, and nothing " +
+            "else:\n{previous}",
+    };
+}
 export function reaskStage(review) {
     return {
         ...review,

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

@@ -0,0 +1,32 @@
+/**
+ * PURE tier ceiling for a whole /go run (spec: sandbox harness parity).
+ *
+ * The eval and template-smoke lanes need to exercise the REAL pipeline without
+ * paying real peak-tier review: a template rebuild's smoke run is a correctness
+ * check, not a quality benchmark. `YAGNI_GO_TIER_CAP=<rung>` clamps every stage
+ * and every child at that ceiling; unset (the default everywhere else) leaves
+ * the pipeline's own per-stage routing untouched.
+ *
+ * The clamp is applied in ONE place — `runStage`, the single seam every stage,
+ * review lens, format re-ask and subagent child passes through on its way to a
+ * pi invocation — and the env var rides the child env, so a grandchild (a
+ * subagent spawned by a stage) resolves the same ceiling from its own process.
+ *
+ * A cap only ever lowers a tier: naming a cap ABOVE a stage's own tier never
+ * promotes it (the pipeline's routing is the judgment; the cap is a budget).
+ */
+import type { ModelTier } from "./types.js";
+/** The documented env var. Eval/smoke lanes only; unset everywhere else. */
+export declare const TIER_CAP_ENV = "YAGNI_GO_TIER_CAP";
+/**
+ * Parse a raw env value into a cap. Unset, empty, or unrecognized all yield
+ * undefined (no cap): a typo must never silently route a run onto some other
+ * tier, and a lane that meant to cap can see the honest "no cap" in the run's
+ * result object.
+ */
+export declare function parseTierCap(raw: string | undefined): ModelTier | undefined;
+/** The effective tier for a stage under a cap: never above it, never promoted. */
+export declare function clampTier(tier: ModelTier, cap: ModelTier | undefined): ModelTier;
+/** Resolve the run's cap from an environment (the child env, or process.env). */
+export declare function resolveTierCap(env: NodeJS.ProcessEnv): ModelTier | undefined;
+//# sourceMappingURL=tierCap.d.ts.map

package/dist/extension/pipeline/tierCap.js

@@ -0,0 +1,57 @@
+/**
+ * PURE tier ceiling for a whole /go run (spec: sandbox harness parity).
+ *
+ * The eval and template-smoke lanes need to exercise the REAL pipeline without
+ * paying real peak-tier review: a template rebuild's smoke run is a correctness
+ * check, not a quality benchmark. `YAGNI_GO_TIER_CAP=<rung>` clamps every stage
+ * and every child at that ceiling; unset (the default everywhere else) leaves
+ * the pipeline's own per-stage routing untouched.
+ *
+ * The clamp is applied in ONE place — `runStage`, the single seam every stage,
+ * review lens, format re-ask and subagent child passes through on its way to a
+ * pi invocation — and the env var rides the child env, so a grandchild (a
+ * subagent spawned by a stage) resolves the same ceiling from its own process.
+ *
+ * A cap only ever lowers a tier: naming a cap ABOVE a stage's own tier never
+ * promotes it (the pipeline's routing is the judgment; the cap is a budget).
+ */
+/** The documented env var. Eval/smoke lanes only; unset everywhere else. */
+export const TIER_CAP_ENV = "YAGNI_GO_TIER_CAP";
+/**
+ * Rung order, lowest first. `balanced` is not a rung a cap can name (it is a
+ * session routing policy, not a tier a child runs on — see mapModelTier), but a
+ * stage carrying it still needs a comparable rank, so it sits with `standard`,
+ * the concrete tier balanced resolves to.
+ */
+const RANK = {
+    efficient: 0,
+    standard: 1,
+    balanced: 1,
+    advanced: 2,
+    peak: 3,
+};
+/** The rungs a cap may name (`balanced` is deliberately excluded). */
+const CAPPABLE = ["efficient", "standard", "advanced", "peak"];
+/**
+ * Parse a raw env value into a cap. Unset, empty, or unrecognized all yield
+ * undefined (no cap): a typo must never silently route a run onto some other
+ * tier, and a lane that meant to cap can see the honest "no cap" in the run's
+ * result object.
+ */
+export function parseTierCap(raw) {
+    const normalized = raw?.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    return CAPPABLE.includes(normalized) ? normalized : undefined;
+}
+/** The effective tier for a stage under a cap: never above it, never promoted. */
+export function clampTier(tier, cap) {
+    if (!cap)
+        return tier;
+    return RANK[tier] > RANK[cap] ? cap : tier;
+}
+/** Resolve the run's cap from an environment (the child env, or process.env). */
+export function resolveTierCap(env) {
+    return parseTierCap(env[TIER_CAP_ENV]);
+}
+//# sourceMappingURL=tierCap.js.map

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

@@ -7,6 +7,7 @@
  * §7.2) so future complexity-lanes select a subset, never a rewrite.
  */
 import type { RunUsage } from "./budget.js";
+import type { PartitionWidth, WorkstreamTier } from "./fanout.js";
 /**
  * Opaque per-stage model tier. These map to models server-side under the `yagni`
  * provider — never a model id in the pipeline config. The pipeline uses `peak`
@@ -48,6 +49,19 @@ export interface PipelineStage {
     taskTemplate: string;
     /** Only set when the stage is fanned out per review lens. */
     lens?: ReviewLens;
+    /**
+     * Only set when the stage is a fan-out child of the implement diamond: the
+     * name of the workstream this child owns. The direct analogue of `lens` on the
+     * review fan-out — it never changes {@link StageId} (the diamond lives INSIDE
+     * the implement boundary), it just attributes the child.
+     */
+    workstream?: string;
+    /**
+     * Extra system-prompt text appended after the persona body (see
+     * `personaBody`). The fan-out builders use it for their per-workstream clause:
+     * claimed files, sibling claims, and the shared-worktree discipline rules.
+     */
+    personaClause?: string;
 }
 /** A single structured review finding parsed from a reviewer's output. */
 export interface Finding {
@@ -70,6 +84,13 @@ export interface StageUsage {
 export interface StageResult {
     stageId: StageId;
     agent: string;
+    /**
+     * The tier this stage ACTUALLY ran on: the stage's own tier, or the
+     * `YAGNI_GO_TIER_CAP` ceiling when the run is capped (eval/smoke lanes). Set
+     * by `runStage`; optional because a caller-injected runStage seam (the unit
+     * tests, a custom lane) need not report one.
+     */
+    tier?: ModelTier;
     exitCode: number;
     finalOutput: string;
     usage: StageUsage;
@@ -202,8 +223,55 @@ export interface PipelineResult {
  *                   Purely informational for later sessions — planResume ignores it.
  *  - `run_finish` : the run reached a terminal stopReason — makes the key NOT
  *                   resumable (a completed run, even `round_cap`, is not "interrupted").
+ *  - `fanout_decision`: the implement diamond resolved how to build (fan + width,
+ *                   or the single-writer degrade and why). Purely informational —
+ *                   `planResume` ignores it, exactly as it ignores `finish_done` —
+ *                   so the decision survives the run for the journal and the /go
+ *                   status surfaces without ever steering a resume.
+ */
+export type CheckpointKind = "run_start" | "build_done" | "round_done" | "finish_done" | "run_finish" | "fanout_decision";
+/**
+ * The recorded implement-diamond verdict (spec decision 2 + 3): the fan and its
+ * width, or the single-writer degrade, always with the reason that produced it —
+ * the orchestrator's own words, the budget seam's, or the pipeline's when a
+ * partition could not be read. `workstreams` carries the shape of the fan (name,
+ * tier, how many paths it claimed), never the claims themselves: the journal is a
+ * decision record, not a second copy of the partition.
+ */
+export interface FanoutCheckpoint {
+    mode: "fan" | "single";
+    width?: PartitionWidth;
+    reason: string;
+    workstreams?: FanoutWorkstreamShape[];
+}
+/**
+ * The shape of ONE workstream as the run records it: its name, the tier it was
+ * assigned, and how many paths it claimed. Never the claims themselves — a
+ * recording surface names the child and how much of the plan it holds, and the
+ * partition itself stays in the stage's own handoff.
+ */
+export interface FanoutWorkstreamShape {
+    name: string;
+    tier: WorkstreamTier;
+    files: number;
+}
+/**
+ * `go.fanout`: `auto` lets the partitioner's own (conservative) verdict stand;
+ * `always` pins the diamond attempt for benchmark/eval lanes — it tells the
+ * partitioner this run is pinned and overrides a budget denial, but it can still
+ * only fan on a partition the orchestrator actually produced (a partition is
+ * never guessed, spec decision 3).
+ */
+export type FanoutMode = "auto" | "always";
+/**
+ * The injected budget seam's verdict (spec decision 8). The budget machinery is a
+ * separate workstream; this pipeline only consults the seam, and an ABSENT seam
+ * allows. `reason` is rendered as the recorded single-writer decision.
  */
-export type CheckpointKind = "run_start" | "build_done" | "round_done" | "finish_done" | "run_finish";
+export interface FanoutBudgetVerdict {
+    allow: boolean;
+    reason?: string;
+}
 /** One append-only journal record. Latest-applicable record wins on resume. */
 export interface CheckpointRecord {
     v: 1;
@@ -235,6 +303,8 @@ export interface CheckpointRecord {
     commitSha?: string;
     /** finish_done: the PR opened by --pr (absent when none was). */
     prUrl?: string;
+    /** fanout_decision: how the implement stage resolved to build (see {@link FanoutCheckpoint}). */
+    fanout?: FanoutCheckpoint;
     /** Cumulative run usage through this completed boundary. */
     usage?: RunUsage;
 }
@@ -343,6 +413,13 @@ export interface StageTag {
     stageId: StageId;
     lens?: ReviewLens;
     round?: number;
+    /**
+     * Which fan-out child of the implement diamond this event belongs to. Set for
+     * the parallel builders (and their fix-turn re-engagements) exactly the way
+     * `lens` is set for the parallel review children, so interleaved events from
+     * concurrent builders stay attributed. Absent on the single-writer path.
+     */
+    workstream?: string;
 }
 /**
  * Structured progress signal (replaces the bare `onProgress(string)`); the feed
@@ -355,11 +432,14 @@ export type PipelineProgress = {
     kind: "stage_start";
     stageId: FeedStageId;
     lens?: ReviewLens;
+    workstream?: string;
     round?: number;
 } | {
     kind: "stage_done";
     stageId: FeedStageId;
     lens?: ReviewLens;
+    /** The fan-out child this beat belongs to (implement diamond); see {@link StageTag}. */
+    workstream?: string;
     round?: number;
     /**
      * Per-lens finding counts. Attached only on the SECOND `stage_done` a lens
@@ -380,12 +460,51 @@ export type PipelineProgress = {
     round: number;
     total: number;
     blocking: number;
+}
+/**
+ * The implement diamond's partition verdict, emitted once per implement stage
+ * the moment it resolves: the fan and its width, or the single-writer degrade.
+ * `reason` is the orchestrator's own words (or the budget seam's), so the
+ * terminal summary and the run surface render the decision that was actually
+ * made rather than inferring one from the children that followed.
+ *
+ * `workstreams` carries the fan's shape (the same record the checkpoint
+ * journal keeps) so a recording surface can name each child, and its tier and
+ * claim count, from the decision alone rather than waiting to infer them from
+ * the beats that follow. Absent on the single-writer degrade.
+ */
+ | {
+    kind: "fanout";
+    mode: "fan" | "single";
+    width?: PartitionWidth;
+    reason: string;
+    workstreams?: FanoutWorkstreamShape[];
+}
+/**
+ * One bounded fix turn of the implement diamond (spec decision 7): the turn
+ * number, how many findings that turn was answering, and which children were
+ * re-engaged to answer them (workstream names, or the synthesizer for
+ * unattributable findings). Emitted at most {@link MAX_FIX_TURNS} times per
+ * implement stage, and on the single-writer path too.
+ */
+ | {
+    kind: "fix_turn";
+    turn: number;
+    findings: number;
+    reengaged: string[];
 } | {
     kind: "done";
     stopReason: StopReason;
 };
 /** Stop the review→fix loop after at most this many rounds (spec §7.3). */
 export declare const MAX_REVIEW_ROUNDS = 3;
+/**
+ * Hard cap on the implement diamond's fix turns (spec decision 7). Verification
+ * may re-engage the builders that broke the tree, but only this many times: past
+ * the cap the remaining findings are named in `reviewInput` and the review loop
+ * takes over, rather than the stage grinding on the same defect forever.
+ */
+export declare const MAX_FIX_TURNS = 3;
 /**
  * R1 in-loop resilience policy: the tuning surface for {@link withResilience},
  * the HOF that wraps every per-stage child spawn with idle + wall-clock timeouts
@@ -430,6 +549,16 @@ export declare const TOOL_ERROR_FAIL_RATE = 0.6;
 export declare const MIN_TOOL_CALLS_FOR_HEALTH = 4;
 /** Bound on parallel review-lens children per round (mirrors the subagent example). */
 export declare const MAX_CONCURRENCY = 4;
+/**
+ * Bound on parallel implement-diamond builders, and the wider ceiling while the
+ * session is in ultra mode. Deliberately the same numbers as the general subagent
+ * tool's `MAX_PARALLEL_SUBAGENTS` / `MAX_PARALLEL_SUBAGENTS_ULTRA` (subagents.ts)
+ * — one proven parallel-children ceiling for this process, restated here so the
+ * pipeline never imports the tool layer. A width-8 partition is therefore legal
+ * outside ultra: it runs 4 at a time rather than being refused.
+ */
+export declare const MAX_FANOUT_CONCURRENCY = 4;
+export declare const MAX_FANOUT_CONCURRENCY_ULTRA = 8;
 /** Per-stage final-output byte cap when handed forward as `{previous}`. */
 export declare const PER_TASK_OUTPUT_CAP: number;
 /** Max length of a narration headline surfaced into the feed (spec §3). */

package/dist/extension/pipeline/types.js

@@ -8,6 +8,13 @@
  */
 /** Stop the review→fix loop after at most this many rounds (spec §7.3). */
 export const MAX_REVIEW_ROUNDS = 3;
+/**
+ * Hard cap on the implement diamond's fix turns (spec decision 7). Verification
+ * may re-engage the builders that broke the tree, but only this many times: past
+ * the cap the remaining findings are named in `reviewInput` and the review loop
+ * takes over, rather than the stage grinding on the same defect forever.
+ */
+export const MAX_FIX_TURNS = 3;
 /**
  * Default resilience policy. Generous timeouts so a legitimately long but live
  * stage is never killed (the idle window sits well under the 5-min run heartbeat,
@@ -39,6 +46,16 @@ export const TOOL_ERROR_FAIL_RATE = 0.6;
 export const MIN_TOOL_CALLS_FOR_HEALTH = 4;
 /** Bound on parallel review-lens children per round (mirrors the subagent example). */
 export const MAX_CONCURRENCY = 4;
+/**
+ * Bound on parallel implement-diamond builders, and the wider ceiling while the
+ * session is in ultra mode. Deliberately the same numbers as the general subagent
+ * tool's `MAX_PARALLEL_SUBAGENTS` / `MAX_PARALLEL_SUBAGENTS_ULTRA` (subagents.ts)
+ * — one proven parallel-children ceiling for this process, restated here so the
+ * pipeline never imports the tool layer. A width-8 partition is therefore legal
+ * outside ultra: it runs 4 at a time rather than being refused.
+ */
+export const MAX_FANOUT_CONCURRENCY = 4;
+export const MAX_FANOUT_CONCURRENCY_ULTRA = 8;
 /** Per-stage final-output byte cap when handed forward as `{previous}`. */
 export const PER_TASK_OUTPUT_CAP = 50 * 1024;
 /** Max length of a narration headline surfaced into the feed (spec §3). */

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

@@ -9,9 +9,11 @@
  * the fix stage gets the real errors.
  *
  * `detectVerifyCommands`, `detectVerifyTestCommands`, `parseVerifyFailures`,
- * `classifyTestFailure`, `isFannedOutScript`, `parseChangedPaths` and
- * `resolvePackageDirs` are PURE (unit-tested directly). `makeRunVerify` is the
- * thin impure runner; it shells out (pi's ExtensionContext exposes no exec,
+ * `classifyTestFailure`, `isFannedOutScript`, `parseChangedPaths`,
+ * `resolvePackageDirs` and `resolveClaimDirs` are PURE (unit-tested directly).
+ * `makeRunVerify` (the whole gate) and `makeWorkstreamCheck` (the implement
+ * diamond's per-workstream scoped typecheck, spec decision 6) are the thin impure
+ * runners; they shell out (pi's ExtensionContext exposes no exec,
  * mirroring workspace.ts) and is wrapped with R1's timeout composition
  * (`composeAbortSignal`) so a slow or flaky suite is bounded.
  *
@@ -215,6 +217,22 @@ export declare function classifyTestFailure(output: string, exitCode: number): T
  * throws; always emits at least one finding on a non-zero exit.
  */
 export declare function parseVerifyFailures(output: string, exitCode: number, label: string): Finding[];
+/**
+ * One finding's file as the REPO ROOT sees it.
+ *
+ * The gate is scoped by design: a monorepo package's `typecheck` / `test` runs
+ * IN that package's dir, so its diagnostics come back package-relative
+ * (`src/routes/x.ts`). Everything downstream speaks repo-root-relative paths —
+ * the partition's file claims, the handoff, the fix loop's attribution
+ * (`checker.ts`'s `ownerOf`) — so an un-lifted path can never match the
+ * workstream that owns it and the implicated builder is never re-engaged.
+ *
+ * Lifts a package-relative path onto the command's dir, makes an absolute path
+ * under the repo root relative to it, and leaves anything else (a path outside
+ * the tree, a path already carrying the package prefix) untouched. Idempotent,
+ * so a finding that passes through twice is not double-prefixed.
+ */
+export declare function toRepoRelativePath(file: string, repoRoot: string, commandCwd: string): string;
 /** Result of actually executing the resolved command. */
 export interface VerifyExecResult {
     code: number;
@@ -268,6 +286,71 @@ export interface MakeRunVerifyOpts {
     /** Test-half env override for determinism in tests (default: buildTestEnv() per run). */
     testEnv?: NodeJS.ProcessEnv;
 }
+/**
+ * One workstream as the scoped checker sees it: the name its findings are
+ * attributed to, and the prefix claims the partition gave it.
+ */
+export interface WorkstreamCheckTarget {
+    name: string;
+    files: string[];
+}
+/**
+ * One workstream's scoped typecheck verdict (spec decision 6, first half).
+ * `ran: false` is the honest fail-open: the claims resolved to no package with a
+ * usable build check, so the workstream is UNCHECKED rather than falsely clean.
+ */
+export interface WorkstreamCheckResult {
+    name: string;
+    ran: boolean;
+    ok: boolean;
+    command?: string;
+    reason?: string;
+    findings: Finding[];
+}
+/**
+ * A workstream's claims resolved to package dirs. Claims are PREFIXES and a claim
+ * is very often a directory (`packages/backend/src/routes`), while
+ * {@link resolvePackageDirs} takes the FILE paths git porcelain emits and walks up
+ * from each one's dirname. Appending a probe segment makes a directory claim walk
+ * up from the directory ITSELF, so a claim that IS a package dir resolves to that
+ * package instead of its parent; a claim that is a real file still resolves exactly
+ * as it does for the full gate. Pure (the `readFile` seam keeps it so).
+ */
+export declare function resolveClaimDirs(repoRoot: string, claims: string[], readFile: (path: string) => string): string[];
+export interface MakeWorkstreamCheckOpts {
+    /** Claims → package dirs. Default: {@link resolveClaimDirs} over the real fs. */
+    claimDirs?: (cwd: string, claims: string[]) => string[];
+    /** The build check(s) for those dirs. Default: the same detection the full gate uses. */
+    detect?: (cwd: string, claimDirs: string[]) => VerifyCommand[];
+    exec?: VerifyExec;
+    timeoutMs?: number;
+}
+/**
+ * The per-workstream scoped check the implement diamond runs right after the fan
+ * (spec decision 6): the TYPECHECK half only, run in the package dirs a
+ * workstream's own claims resolve to, so a broken workstream is caught WITH
+ * attribution instead of surfacing later as an anonymous failure of the merged
+ * tree. The test half is deliberately not run here — the repo's tests run ONCE, on
+ * the merged candidate, through {@link makeRunVerify}.
+ *
+ * Three rules keep the attribution honest:
+ *  - a command is kept only when it runs IN one of the workstream's own claim dirs.
+ *    {@link detectVerifyCommands} falls back to the repo-root script when nothing
+ *    scoped qualifies, and a repo-wide typecheck blamed on one workstream is
+ *    exactly the false attribution this check exists to avoid.
+ *  - identical commands are executed ONCE per pass and their result shared, so two
+ *    workstreams inside the same package do not typecheck it twice.
+ *  - a workstream is tagged only with the failures its OWN claims cover. A shared
+ *    package's check can fail on its sibling's files (or on files neither claims):
+ *    tagging every target with the whole output would report a healthy workstream
+ *    broken and defeat the checker's file+line+message dedupe against the full
+ *    verify. Failures outside the target's claims surface ONCE, untagged, so
+ *    {@link attributeFindings} routes them by file or hands them to the synthesizer.
+ *
+ * Fail-open everywhere, like the full gate: an unrunnable check records a reason
+ * and produces no findings.
+ */
+export declare function makeWorkstreamCheck(opts?: MakeWorkstreamCheckOpts): (cwd: string, targets: WorkstreamCheckTarget[], signal?: AbortSignal) => Promise<WorkstreamCheckResult[]>;
 /**
  * Build the runVerify function injected into the orchestrator. It discovers the
  * changed package(s) (scoped to this run's diff via `baselinePaths`), detects a