@yagni-app/code-staging 0.3.2-staging.1112.1 → 0.3.2-staging.1115.1

package/dist/extension/index.js

@@ -28,6 +28,7 @@ import { fetchMcpServers as defaultFetchMcpServers, registerMcpCommand, register
 import { registerGoCommand } from "./pipeline/goCommand.js";
 import { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
 import { DEFAULT_PERMISSION_POLICY, createModeHolder, registerPermissionGate } from "./permission.js";
+import { loadHooksConfig, makeHookRunner, registerHooks } from "./hooks.js";
 import { registerSubagents } from "./subagents.js";
 import { createUltraHolder, registerUltraCommand } from "./ultra.js";
 import { registerTodos } from "./todos.js";
@@ -206,6 +207,10 @@ export async function registerYagni(pi, deps = {}) {
     // The grounded multi-agent pipeline entry point: /go <ticket> runs
     // map → plan → implement → review → fix, each child grounded by inheritance.
     registerGoCommand(pi, {
+        // /ultra is one dial for the whole session: the same holder the subagent
+        // tool reads widens the implement diamond's parallel ceiling (4 -> 8) for
+        // the fan and its fix turns. Read per run, so a toggle lands on the next /go.
+        isUltra: () => ultraHolder.get(),
         // Task 8: /go's end-of-run summary prefers the server-priced per-stage
         // breakdown for the ONE run that just finished (`?runId=`, aliasing the
         // spend endpoint's `sessionId` param — see the backend route), over
@@ -280,6 +285,12 @@ export async function registerYagni(pi, deps = {}) {
     // rejected as a same-session self-authorization path, PR #1698).
     const sessionGrants = evalMode ? [] : loadGrants();
     const GUARDIAN_EVENT_TIMEOUT_MS = 5_000;
+    // YAG-506: load user-configurable lifecycle hooks config and create the
+    // hook runner for the permission gate. Skipped in eval mode.
+    const hooksConfig = evalMode ? {} : loadHooksConfig();
+    const hookRunner = evalMode ? null : makeHookRunner({ config: hooksConfig });
+    if (!evalMode)
+        registerHooks(pi, { config: hooksConfig });
     registerPermissionGate(pi, {
         modeHolder,
         guardianState,
@@ -362,6 +373,7 @@ export async function registerYagni(pi, deps = {}) {
         onBlessRemember: decisionCapture
             ? (ctx, info) => decisionCapture.captureFromBless(ctx, info)
             : undefined,
+        ...(hookRunner ? { hookRunner } : {}),
     });
     // P2/YAG-383: /cost prefers the server-authoritative session spend (covers
     // subagents and advisor consults directly, since they bill under this same
@@ -859,12 +871,22 @@ export { runInitPass, runTeamSetup, registerTeamSetupCommand, isFreshWorkspace,
 // Onramp Door B (F2a): the one-time init-pass idempotency marker.
 export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
 export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA, BRAND_NAME } from "./branding.js";
+// YAG-506: user-configurable lifecycle hooks.
+export { loadHooksConfig, makeHookRunner, registerHooks, matchesMatcher, parsePreToolUseOutput, parsePermissionRequestOutput, parseAdditionalContext, parseCompactCancel, HOOK_SUPPORTED_EVENTS, } from "./hooks.js";
 // Ultra mode (/ultra): the aggressive fan-out/verify/synthesize dial.
 export { createUltraHolder, registerUltraCommand } from "./ultra.js";
 export { attributionHeaders, isDriverCaller, fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl, sanitizeCallerSegment, } from "./config.js";
 export { buildYagniProvider } from "./provider.js";
 export { registerGoCommand } from "./pipeline/goCommand.js";
 export { runPipeline } from "./pipeline/orchestrator.js";
+// The headless front door (`yagni go --headless`): the same pipeline, driven by
+// a script or the mission sandbox instead of a session.
+export { HEADLESS_GO_EXIT, HEADLESS_GO_USAGE, parseHeadlessGoArgs, runHeadlessGo, validateHeadlessGoArgs, } from "./pipeline/headlessGo.js";
+// Mission mode: the pure rules for entering the pipeline on an already-approved
+// plan (map/plan skipped, memo as the stand-in repo brief, FINISH not ours).
+export { isMissionMode, missionSeed, missionSkippedStages, normalizeMission } from "./pipeline/mission.js";
+// The eval/smoke tier ceiling (YAGNI_GO_TIER_CAP), clamped centrally in runStage.
+export { clampTier, parseTierCap, resolveTierCap, TIER_CAP_ENV } from "./pipeline/tierCap.js";
 // R1: the in-loop resilience HOF a dev can compose with (or replace at) the
 // `runStage` seam, plus its policy type and the default policy.
 export { withResilience, classifyTransient, composeAbortSignal } from "./pipeline/resilience.js";

package/dist/extension/permission.d.ts

@@ -28,6 +28,7 @@
  */
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type ApprovedPrefixGrant } from "./approvedPrefixes.js";
+import type { HookRunner } from "./hooks.js";
 import { type BlessStore } from "./bless.js";
 import { type ExecPolicy } from "./execPolicy.js";
 import { type GuardianError, type GuardianRiskLevel } from "./guardian.js";
@@ -179,6 +180,12 @@ export interface RegisterPermissionDeps {
      * Fail-soft; never blocks.
      */
     onGuardianEvent?: (event: GuardianGateEvent) => void;
+    /**
+     * User-configurable lifecycle hooks (YAG-506). When present, PreToolUse
+     * hooks run before decideGate and can short-circuit (allow/deny/ask),
+     * and PermissionRequest hooks run before the confirm dialog.
+     */
+    hookRunner?: HookRunner;
 }
 /** The customType tag on injected mode-context messages (filterable later). */
 export declare const MODE_CONTEXT_TYPE = "yagni-mode-context";

package/dist/extension/permission.js

@@ -296,6 +296,7 @@ export function registerPermissionGate(pi, deps = {}) {
     const basePolicy = deps.policy ?? DEFAULT_PERMISSION_POLICY;
     let mode = deps.mode ?? "auto";
     const makeStore = deps.makeBlessStore ?? defaultMakeBlessStore;
+    const hookRunner = deps.hookRunner;
     deps.modeHolder?.onSet((m) => {
         if (m !== mode)
             approvedCommands.clear();
@@ -422,7 +423,48 @@ export function registerPermissionGate(pi, deps = {}) {
         const modeAtEntry = mode;
         try {
             const input = event.input ?? {};
-            const decision = decideGate(event.toolName, input, modeAtEntry, effectivePolicy);
+            // YAG-506: PreToolUse hooks run BEFORE decideGate. They can short-circuit
+            // (allow/deny/ask) or fall through to the normal gate logic. The result
+            // is cached in preToolUseResult so the "ask" check below does NOT
+            // re-invoke the hook (hooks have side effects — notifications etc.).
+            let preToolUseResult;
+            if (hookRunner) {
+                const cwd = ctx?.cwd ?? ".";
+                try {
+                    preToolUseResult = await hookRunner.preToolUse(event.toolName, input, cwd, ctx?.isProjectTrusted()) ?? undefined;
+                    if (preToolUseResult) {
+                        if (preToolUseResult.decision === "deny") {
+                            return { block: true, reason: preToolUseResult.reason };
+                        }
+                        if (preToolUseResult.decision === "allow") {
+                            // Allow bypasses Guardian/confirm, but the exec policy's forbidden
+                            // band still runs as a hard safety floor (deliberate deviation
+                            // from Claude Code: we don't let a hook auto-allow a forbidden cmd).
+                            if (event.toolName === "bash") {
+                                const cmdRaw = input.command;
+                                const command = typeof cmdRaw === "string" ? cmdRaw.trim() : "";
+                                if (command) {
+                                    const execPolicy = effectivePolicy.execPolicy ?? DEFAULT_EXEC_POLICY;
+                                    const classification = classifyCommand(command, execPolicy);
+                                    if (classification.decision === "forbidden") {
+                                        return {
+                                            block: true,
+                                            reason: `${classification.justification}. Do not attempt the same outcome via a workaround or indirect execution — use a materially safer alternative, or ask the user.`,
+                                        };
+                                    }
+                                }
+                            }
+                            return {};
+                        }
+                        // "ask" → force confirm by overriding the gate decision
+                        // Falls through to decision.confirm logic below
+                    }
+                }
+                catch {
+                    // Fail-soft: a hook error never blocks or allows; fall through to gate
+                }
+            }
+            let decision = decideGate(event.toolName, input, modeAtEntry, effectivePolicy);
             if (decision.block)
                 return { block: true, reason: decision.reason };
             // Prompt band (YAG-510 order): grants → exact-command cache → cap/
@@ -587,6 +629,41 @@ export function registerPermissionGate(pi, deps = {}) {
                                 reason: `Guardian needs user approval: ${verdict.rationale} No UI available — the command was held. Find a safer alternative or leave this step for the user.`,
                             };
                         }
+                        // YAG-506: PermissionRequest hooks fire before the confirm dialog.
+                        // Only when a UI is present (headless path already failed closed above).
+                        if (hookRunner && ctx?.hasUI) {
+                            try {
+                                const hookResult = await hookRunner.permissionRequest(event.toolName, input, cwd, ctx?.isProjectTrusted());
+                                if (hookResult) {
+                                    if (hookResult.decision === "allow") {
+                                        rememberApproved(cwd, command);
+                                        emitGateEvent({
+                                            ...eventBase,
+                                            outcome: "ask_approved",
+                                            riskLevel: verdict.riskLevel,
+                                            rationale: verdict.rationale,
+                                            durationMs,
+                                            consulted: true,
+                                        });
+                                        return {};
+                                    }
+                                    if (hookResult.decision === "deny") {
+                                        emitGateEvent({
+                                            ...eventBase,
+                                            outcome: "ask_denied",
+                                            riskLevel: verdict.riskLevel,
+                                            rationale: verdict.rationale,
+                                            durationMs,
+                                            consulted: true,
+                                        });
+                                        return { block: true, reason: hookResult.reason };
+                                    }
+                                }
+                            }
+                            catch {
+                                // Fail-soft: hook error → dialog proceeds normally
+                            }
+                        }
                         // Offer "don't ask again" only when the grant would actually
                         // cover this command (grant-time validation).
                         const grantCandidate = validateGrant(command, effectivePolicy.execPolicy ?? DEFAULT_EXEC_POLICY, resolveRepoKeyFor(cwd));
@@ -725,7 +802,29 @@ export function registerPermissionGate(pi, deps = {}) {
                 }
                 // review mode with Guardian disabled/capped: fall through to confirm.
             }
+            // YAG-506: PreToolUse "ask" forces confirmation even in auto mode.
+            // Uses the cached result from the top of the handler — no re-invocation.
+            if (preToolUseResult?.decision === "ask") {
+                decision = { block: false, confirm: true };
+            }
             if (decision.confirm) {
+                // YAG-506: PermissionRequest hooks run before the confirm dialog.
+                if (hookRunner) {
+                    try {
+                        const cwd = ctx?.cwd ?? ".";
+                        const hookResult = await hookRunner.permissionRequest(event.toolName, input, cwd, ctx?.isProjectTrusted());
+                        if (hookResult) {
+                            if (hookResult.decision === "allow")
+                                return {};
+                            if (hookResult.decision === "deny") {
+                                return { block: true, reason: hookResult.reason };
+                            }
+                        }
+                    }
+                    catch {
+                        // Fail-soft: hook error → dialog proceeds normally
+                    }
+                }
                 // Review mode needs a confirmation. With no dialog-capable UI (headless),
                 // fail CLOSED: the user explicitly chose a stricter mode, so a write we
                 // cannot get consent for is held rather than silently auto-applied (this

package/dist/extension/pipeline/activityFeed.js

@@ -92,9 +92,10 @@ export class ActivityFeed {
     }
     /** Fold a structured progress signal into stage transitions + the header tally. */
     applyProgress(p) {
-        // A per-lens signal is a desktop concern: it must not steal the buffer from
-        // the review stage that owns it, nor reset it mid fan-out.
-        if (p.kind === "stage_start" && !p.lens && p.stageId !== this.bufferStageId) {
+        // A per-lens or per-workstream signal is a desktop concern: it must not steal
+        // the buffer from the stage that owns it, nor reset it mid fan-out. The
+        // implement diamond's builders get exactly the review lenses' treatment.
+        if (p.kind === "stage_start" && !p.lens && !p.workstream && p.stageId !== this.bufferStageId) {
             this.bufferStageId = p.stageId;
             this.actions = [];
         }
@@ -129,6 +130,10 @@ export class ActivityFeed {
             headerParts.push(elapsed);
         const header = theme.bold(clipRow(headerParts.join(" · "), ROW_MAX));
         const lines = [header];
+        // The implement diamond collapses to ONE row plus a compact summary, the same
+        // way the review fan-out collapses to one review row: per-child rows are the
+        // desktop's business and would break the 10-line cap here.
+        const fan = this.run.fanoutRow();
         // Only the lens-less stage rows: the review fan-out's per-lens children are
         // the desktop's business, and surfacing them here would break the 10-line cap.
         for (const s of this.run.stageAgents()) {
@@ -138,8 +143,17 @@ export class ActivityFeed {
             if (s.id === "finish" && s.status === "pending")
                 continue;
             const glyph = glyphForStatus(s.status, spinnerFrame);
-            const label = s.stageId.padEnd(9);
-            const row = clipRow(`${glyph} ${label}${s.summary}`.trimEnd(), ROW_MAX);
+            // Padded past the longest stage name ("implement", 9) so every row keeps a
+            // separator between the label and its note; at 9 the implement row ran its
+            // name straight into its own summary.
+            const label = s.stageId.padEnd(10);
+            // While the fan is live the implement row's note IS the fan summary; once
+            // the stage settles its own narration takes the row back (and the summary
+            // stands in when there is no narration to show).
+            const fanNote = s.stageId === "implement" && fan?.mode === "fan" && (s.status === "active" || !s.summary)
+                ? `fanned ${fan.total} ways · ${fan.done}/${fan.total} done`
+                : undefined;
+            const row = clipRow(`${glyph} ${label}${fanNote ?? s.summary}`.trimEnd(), ROW_MAX);
             lines.push(theme.fg(themeColorForStatus[s.status], row));
             // The ring buffer renders under its OWNING stage (see RunState), so a
             // just-finished stage's resolved actions stay briefly visible beneath its ✔

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

@@ -0,0 +1,99 @@
+/**
+ * PURE checker-side helpers for the implement diamond (spec decisions 5-7).
+ *
+ * The checker itself is deterministic and lives in `verify.ts` (the per-workstream
+ * scoped typecheck plus the one full `makeRunVerify` on the merged tree). What is
+ * left is the reading of its verdict, and that is all pure text math:
+ *
+ *  - {@link checkerFindings} unions the scoped + full findings into one deduped list.
+ *  - {@link composeSynthesizerInput} turns the fan handoff plus the checker's
+ *    verdict into the synthesizer's `{previous}`.
+ *  - {@link attributeFindings} routes each finding to the workstream whose claims
+ *    cover its file; anything unattributable is the synthesizer's (or, on the
+ *    single-writer path, the one builder's).
+ *  - {@link parseOpenFindings} reads the synthesizer's own "## Open findings"
+ *    section, because decision 7 lets the summary report defects the deterministic
+ *    checker cannot see.
+ *  - {@link composeResidue} names what is still open when the fix cap is reached,
+ *    so `reviewInput` hands the review loop the truth rather than a clean-looking
+ *    summary.
+ *
+ * No I/O, no model calls: the orchestrator owns the children, this module owns the
+ * reading, exactly the split `findings.ts` and `fanout.ts` already use.
+ */
+import { type PartitionWorkstream } from "./fanout.js";
+import type { Finding } from "./types.js";
+import type { VerifyOutcome, WorkstreamCheckResult } from "./verify.js";
+/** Everything the deterministic checker produced for one pass over the tree. */
+export interface CheckerReport {
+    /** Per-workstream scoped typecheck verdicts (empty on the single-writer path). */
+    scoped: WorkstreamCheckResult[];
+    /** The one full verify on the merged tree; null when it could not be consulted. */
+    verify: VerifyOutcome | null;
+}
+/** Findings routed to one workstream's builder for a fix turn. */
+export interface FindingAssignment {
+    workstream: PartitionWorkstream;
+    findings: Finding[];
+}
+/** How the fix loop splits a checker verdict across the children that can fix it. */
+export interface FindingAttribution {
+    assigned: FindingAssignment[];
+    /** Findings no workstream's claims cover: the synthesizer's seam work. */
+    unassigned: Finding[];
+}
+/** Union findings in first-seen order, deduped by file + line + message. */
+export declare function mergeFindings(...groups: Finding[][]): Finding[];
+/** Every defect this checker pass found: the scoped typechecks plus the full verify. */
+export declare function checkerFindings(report: CheckerReport): Finding[];
+/** One finding as a line a builder can act on (mirrors the review loop's handoff shape). */
+export declare function renderFindings(findings: Finding[]): string;
+/**
+ * The synthesizer's `{previous}`: the fan's own handoff (which already names each
+ * workstream, its claims, and any out-of-claim edits) plus the checker's verdict,
+ * with a broken workstream attributed BY NAME so the reconciler knows where to look.
+ */
+export declare function composeSynthesizerInput(handoff: string, report: CheckerReport): string;
+/**
+ * Route findings to the builders that can fix them: a finding whose file sits under
+ * a workstream's claims goes to that workstream (at its original tier), and anything
+ * else - no file, a file outside every claim, a seam between two workstreams - is
+ * unattributable and belongs to the synthesizer. With no workstreams (the
+ * single-writer path) everything is unassigned, which is exactly right: there is one
+ * builder and it owns the whole tree.
+ */
+export declare function attributeFindings(findings: Finding[], workstreams: PartitionWorkstream[]): FindingAttribution;
+/**
+ * The synthesizer's own "## Open findings" section (its persona output contract),
+ * as findings the fix loop can act on. "none" is a real answer and returns nothing;
+ * an absent section returns nothing too, because a summary that never claimed a
+ * defect is not evidence of one. Deliberately forgiving about the prose: what the
+ * loop needs is the line and, where the synthesizer named one, the file.
+ */
+export declare function parseOpenFindings(summary: string): Finding[];
+/**
+ * The same "## Open findings" section {@link parseOpenFindings} reads, REMOVED
+ * from a summary (heading and body, up to the next heading of any depth).
+ *
+ * A fix turn that only re-engaged builders never re-runs the synthesizer, so its
+ * summary stays the handoff verbatim. Once those defects are answered and the
+ * re-check is clean, leaving the section in place would hand the review loop a
+ * document that names open defects in one paragraph and calls the final check
+ * clean in the next. Everything else the synthesizer wrote is untouched: this
+ * drops only the section the fix loop has since resolved.
+ */
+export declare function stripOpenFindings(summary: string): string;
+/**
+ * What `reviewInput` says when the fix loop ran and then came back clean: the
+ * reviewers should know the candidate was repaired inside the implement stage, not
+ * that it was right first time. Absent when no fix turn ran, which keeps a
+ * clean-on-the-first-check run byte-identical to today's handoff.
+ */
+export declare function composeFixNote(turns: number): string;
+/**
+ * What `reviewInput` says when the fix cap is reached with defects still open
+ * (spec decision 7): named, not hidden, so the review loop picks them up knowing
+ * the implement stage already spent its turns on them.
+ */
+export declare function composeResidue(findings: Finding[], turns: number): string;
+//# sourceMappingURL=checker.d.ts.map

package/dist/extension/pipeline/checker.js

@@ -0,0 +1,238 @@
+/**
+ * PURE checker-side helpers for the implement diamond (spec decisions 5-7).
+ *
+ * The checker itself is deterministic and lives in `verify.ts` (the per-workstream
+ * scoped typecheck plus the one full `makeRunVerify` on the merged tree). What is
+ * left is the reading of its verdict, and that is all pure text math:
+ *
+ *  - {@link checkerFindings} unions the scoped + full findings into one deduped list.
+ *  - {@link composeSynthesizerInput} turns the fan handoff plus the checker's
+ *    verdict into the synthesizer's `{previous}`.
+ *  - {@link attributeFindings} routes each finding to the workstream whose claims
+ *    cover its file; anything unattributable is the synthesizer's (or, on the
+ *    single-writer path, the one builder's).
+ *  - {@link parseOpenFindings} reads the synthesizer's own "## Open findings"
+ *    section, because decision 7 lets the summary report defects the deterministic
+ *    checker cannot see.
+ *  - {@link composeResidue} names what is still open when the fix cap is reached,
+ *    so `reviewInput` hands the review loop the truth rather than a clean-looking
+ *    summary.
+ *
+ * No I/O, no model calls: the orchestrator owns the children, this module owns the
+ * reading, exactly the split `findings.ts` and `fanout.ts` already use.
+ */
+import { claimCovers } from "./fanout.js";
+/** Cap on how many open findings are ever carried into a prompt or the residue. */
+const MAX_CARRIED_FINDINGS = 25;
+const key = (f) => `${f.file ?? ""}:${f.line ?? ""}:${f.message}`;
+/** Union findings in first-seen order, deduped by file + line + message. */
+export function mergeFindings(...groups) {
+    const seen = new Set();
+    const out = [];
+    for (const group of groups) {
+        for (const f of group) {
+            const k = key(f);
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            out.push(f);
+        }
+    }
+    return out;
+}
+/** Every defect this checker pass found: the scoped typechecks plus the full verify. */
+export function checkerFindings(report) {
+    return mergeFindings(report.scoped.flatMap((s) => s.findings), report.verify?.findings ?? []);
+}
+/** One finding as a line a builder can act on (mirrors the review loop's handoff shape). */
+export function renderFindings(findings) {
+    return findings
+        .slice(0, MAX_CARRIED_FINDINGS)
+        .map((f) => {
+        const loc = f.file ? `${f.file}${f.line != null ? `:${f.line}` : ""}` : "";
+        return `${f.severity} | ${loc} | ${f.message}`;
+    })
+        .join("\n");
+}
+/** One workstream's scoped-typecheck line, stating honestly whether it ran. */
+function scopedLine(s) {
+    if (!s.ran)
+        return `- ${s.name}: not checked (${s.reason ?? "no scoped build check"})`;
+    if (s.findings.length === 0)
+        return `- ${s.name}: clean (${s.command ?? "check"})`;
+    return `- ${s.name}: ${s.findings.length} finding${s.findings.length === 1 ? "" : "s"} (${s.command ?? "check"})`;
+}
+/** The full verify's one-line verdict, including the fail-open case. */
+function verifyLine(verify) {
+    if (!verify)
+        return "The full verify did not run on this pass.";
+    if (!verify.ran)
+        return `The full verify did not produce a verdict: ${verify.reason ?? "it could not run"}.`;
+    const label = verify.command ? ` (${verify.command})` : "";
+    if (verify.ok)
+        return `The full verify passed${label}.`;
+    return `The full verify failed${label}: ${verify.findings.length} finding${verify.findings.length === 1 ? "" : "s"}.`;
+}
+/**
+ * The synthesizer's `{previous}`: the fan's own handoff (which already names each
+ * workstream, its claims, and any out-of-claim edits) plus the checker's verdict,
+ * with a broken workstream attributed BY NAME so the reconciler knows where to look.
+ */
+export function composeSynthesizerInput(handoff, report) {
+    const parts = [handoff];
+    if (report.scoped.length > 0) {
+        parts.push(["## Checker: scoped typecheck per workstream", ...report.scoped.map(scopedLine)].join("\n"));
+    }
+    parts.push(`## Checker: full verify on the merged tree\n${verifyLine(report.verify)}`);
+    const findings = checkerFindings(report);
+    if (findings.length > 0) {
+        parts.push(`## Checker findings\n${renderFindings(findings)}`);
+    }
+    return parts.join("\n\n");
+}
+/** The workstream whose claims cover this finding's file, if exactly one does. */
+function ownerOf(finding, workstreams) {
+    const file = finding.file?.trim();
+    if (!file)
+        return undefined;
+    return workstreams.find((w) => w.files.some((claim) => claimCovers(claim, file)));
+}
+/**
+ * Route findings to the builders that can fix them: a finding whose file sits under
+ * a workstream's claims goes to that workstream (at its original tier), and anything
+ * else - no file, a file outside every claim, a seam between two workstreams - is
+ * unattributable and belongs to the synthesizer. With no workstreams (the
+ * single-writer path) everything is unassigned, which is exactly right: there is one
+ * builder and it owns the whole tree.
+ */
+export function attributeFindings(findings, workstreams) {
+    const assigned = [];
+    const unassigned = [];
+    for (const finding of findings) {
+        const owner = ownerOf(finding, workstreams);
+        if (!owner) {
+            unassigned.push(finding);
+            continue;
+        }
+        const existing = assigned.find((a) => a.workstream.name === owner.name);
+        if (existing)
+            existing.findings.push(finding);
+        else
+            assigned.push({ workstream: owner, findings: [finding] });
+    }
+    return { assigned, unassigned };
+}
+/** A heading line, at any depth: `## Open findings`. */
+const HEADING = /^#{1,6}\s+(.*)$/;
+/** `path/to/file.ts` or `path/to/file.ts:42` — a path token, not prose. */
+const PATH_SHAPE = /^[\w./@-]+\.[A-Za-z]{1,5}(?::\d+)?$/;
+/**
+ * The first path-shaped token in a synthesizer's finding line (backticked first,
+ * since that is how the persona writes paths), with any `:line` suffix dropped so
+ * it compares against claim prefixes. Undefined when the line names no file, which
+ * makes the finding unattributable and therefore the synthesizer's own.
+ */
+function pathIn(line) {
+    const quoted = [...line.matchAll(/`([^`]+)`/g)].map((m) => m[1].trim());
+    for (const token of [...quoted, ...line.split(/[\s,;()[\]]+/)]) {
+        const clean = token.replace(/[.,;:]+$/, "");
+        if (clean.includes("/") && PATH_SHAPE.test(clean))
+            return clean.replace(/:\d+$/, "");
+    }
+    return undefined;
+}
+/**
+ * The synthesizer's own "## Open findings" section (its persona output contract),
+ * as findings the fix loop can act on. "none" is a real answer and returns nothing;
+ * an absent section returns nothing too, because a summary that never claimed a
+ * defect is not evidence of one. Deliberately forgiving about the prose: what the
+ * loop needs is the line and, where the synthesizer named one, the file.
+ */
+export function parseOpenFindings(summary) {
+    const lines = summary.split("\n");
+    const start = lines.findIndex((l) => {
+        const m = l.trim().match(HEADING);
+        return m ? /^open findings\b/i.test(m[1].trim()) : false;
+    });
+    if (start < 0)
+        return [];
+    const body = [];
+    for (const raw of lines.slice(start + 1)) {
+        if (HEADING.test(raw.trim()))
+            break;
+        const line = raw.trim().replace(/^[-*]\s+/, "").trim();
+        if (line)
+            body.push(line);
+    }
+    if (body.length === 0)
+        return [];
+    if (body.length === 1 && /^none\b/i.test(body[0].replace(/[.*_`]/g, "")))
+        return [];
+    return body.slice(0, MAX_CARRIED_FINDINGS).map((line) => {
+        const file = pathIn(line);
+        const finding = {
+            severity: "critical",
+            lens: "does_it_hold",
+            message: `synthesizer: ${line}`,
+        };
+        if (file)
+            finding.file = file;
+        return finding;
+    });
+}
+/**
+ * The same "## Open findings" section {@link parseOpenFindings} reads, REMOVED
+ * from a summary (heading and body, up to the next heading of any depth).
+ *
+ * A fix turn that only re-engaged builders never re-runs the synthesizer, so its
+ * summary stays the handoff verbatim. Once those defects are answered and the
+ * re-check is clean, leaving the section in place would hand the review loop a
+ * document that names open defects in one paragraph and calls the final check
+ * clean in the next. Everything else the synthesizer wrote is untouched: this
+ * drops only the section the fix loop has since resolved.
+ */
+export function stripOpenFindings(summary) {
+    const lines = summary.split("\n");
+    const start = lines.findIndex((l) => {
+        const m = l.trim().match(HEADING);
+        return m ? /^open findings\b/i.test(m[1].trim()) : false;
+    });
+    if (start < 0)
+        return summary;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+        if (HEADING.test(lines[i].trim())) {
+            end = i;
+            break;
+        }
+    }
+    return [...lines.slice(0, start), ...lines.slice(end)].join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+/**
+ * What `reviewInput` says when the fix loop ran and then came back clean: the
+ * reviewers should know the candidate was repaired inside the implement stage, not
+ * that it was right first time. Absent when no fix turn ran, which keeps a
+ * clean-on-the-first-check run byte-identical to today's handoff.
+ */
+export function composeFixNote(turns) {
+    return [
+        "## Verification",
+        `${turns} fix pass${turns === 1 ? "" : "es"} ran inside the implement stage. The final check came back clean.`,
+    ].join("\n");
+}
+/**
+ * What `reviewInput` says when the fix cap is reached with defects still open
+ * (spec decision 7): named, not hidden, so the review loop picks them up knowing
+ * the implement stage already spent its turns on them.
+ */
+export function composeResidue(findings, turns) {
+    const header = turns === 0
+        ? "## Open findings from verification"
+        : `## Open findings after ${turns} fix pass${turns === 1 ? "" : "es"}`;
+    return [
+        header,
+        "Verification still reports these. They were not resolved inside the implement stage:",
+        renderFindings(findings),
+    ].join("\n");
+}
+//# sourceMappingURL=checker.js.map