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

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

@@ -45,7 +45,8 @@
  *  - Always, as the last line: the result object
  *    `{type:"pipeline_result", ok, stopReason, rounds, findings, stages:[{stage,
  *    tier, usage}], …}` — or `{type:"pipeline_error", …}` when a build stage
- *    threw.
+ *    threw. `preexistingFailures` (absent at 0) counts the gate's own
+ *    typecheck, lint and test failures the clean tree already had (YAG-1003).
  *  - Exit codes: 0 ONLY on a verified candidate (a `clean` stop), 1 for any
  *    other outcome or a thrown pipeline error, 2 for a usage/input problem.
  *
@@ -60,7 +61,7 @@
  */
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
-import { makeRunVerify } from "./verify.js";
+import { makeRunVerify, type VerifyBaselineResult } from "./verify.js";
 import { type RunBudget } from "./budget.js";
 import type { Finding, JsonEvent, ModelTier, PipelineStage, StageId, StageTag, StageUsage, StopReason } from "./types.js";
 /** One-line usage copy, shared by every argument error. */
@@ -129,6 +130,11 @@ export interface HeadlessGoResult {
     /** Honest note when the deterministic verify gate gave no verdict. */
     verifyNote?: string;
     verifyCommand?: string;
+    /**
+     * Failures the gate's own typecheck, lint and tests already had on the clean
+     * tree, in its last verdict (YAG-1003): a note, never findings. Absent at 0.
+     */
+    preexistingFailures?: number;
 }
 export interface HeadlessGoOutcome {
     exitCode: number;
@@ -160,6 +166,8 @@ export interface HeadlessGoDeps {
      * there is none). Defaults to the real gate; injected in tests.
      */
     makeRunVerify?: typeof makeRunVerify;
+    /** The verify gate's clean-tree baseline run (YAG-1003). Defaults to the real one; injected in tests. */
+    takeVerifyBaseline?: (cwd: string, dirs: string[], signal?: AbortSignal, budgetMs?: number) => Promise<VerifyBaselineResult>;
     /** stdout sink; one call per NDJSON line, newline added by the caller. */
     write?: (line: string) => void;
     /** stderr sink for human-readable problems. */

package/dist/extension/pipeline/headlessGo.js

@@ -45,7 +45,8 @@
  *  - Always, as the last line: the result object
  *    `{type:"pipeline_result", ok, stopReason, rounds, findings, stages:[{stage,
  *    tier, usage}], …}` — or `{type:"pipeline_error", …}` when a build stage
- *    threw.
+ *    threw. `preexistingFailures` (absent at 0) counts the gate's own
+ *    typecheck, lint and test failures the clean tree already had (YAG-1003).
  *  - Exit codes: 0 ONLY on a verified candidate (a `clean` stop), 1 for any
  *    other outcome or a thrown pipeline error, 2 for a usage/input problem.
  *
@@ -69,7 +70,7 @@ import { normalizeMission } from "./mission.js";
 import { MISSION_CHECKS_FILE_NAME, MISSION_CI_RESULTS_FILE_NAME, readMissionChecksFile, renderCiResults, } from "./missionChecks.js";
 import { startTreeSnapshots } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
-import { makeRunVerify } from "./verify.js";
+import { baselineDirs, makeRunVerify, makeTakeVerifyBaseline, makeWorkstreamCheck, planPaths, } from "./verify.js";
 import { loadGroundingEnabled } from "../grounding.js";
 import { codeStateHome } from "../stateHome.js";
 import { parseTierCap, TIER_CAP_ENV } from "./tierCap.js";
@@ -82,6 +83,9 @@ export const HEADLESS_GO_USAGE = "Usage: yagni go --headless --ticket-file <path
  * can never read as success to a script, a smoke gate, or CI.
  */
 export const HEADLESS_GO_EXIT = { verified: 0, unverified: 1, usage: 2 };
+/** The verify baseline's share of a deadline run's time left, and the least it is worth starting with. */
+const BASELINE_SHARE_OF_TIME_LEFT = 6;
+const MIN_BASELINE_BUDGET_MS = 60_000;
 const VALUE_FLAGS = {
     "--ticket-file": "ticketFile",
     "--plan-file": "planFile",
@@ -204,6 +208,7 @@ function buildResult(result, ctx) {
         ...(finish?.prUrl ? { prUrl: finish.prUrl } : {}),
         ...(result.verifyNote ? { verifyNote: result.verifyNote } : {}),
         ...(result.verifyCommand ? { verifyCommand: result.verifyCommand } : {}),
+        ...(ctx.preexistingFailures ? { preexistingFailures: ctx.preexistingFailures } : {}),
     };
 }
 /** Attribution rider for a streamed child event (never overwrites pi's own keys). */
@@ -327,7 +332,7 @@ export async function runHeadlessGo(argv, deps = {}) {
     // A mission's approved checks and its pull request's CI jobs, written by the
     // host beside the ticket: the verify gate runs them inside the loop. No file
     // (a host that predates it) leaves the gate as it was.
-    let runVerify;
+    let gateOpts;
     if (mission && args.ticketFile) {
         const checksPath = join(dirname(args.ticketFile), MISSION_CHECKS_FILE_NAME);
         const read = readMissionChecksFile(checksPath, readFile);
@@ -349,7 +354,7 @@ export async function runHeadlessGo(argv, deps = {}) {
                     writeErr(`Could not write ${resultsPath}: ${err instanceof Error ? err.message : String(err)}`);
                 }
             };
-            runVerify = (deps.makeRunVerify ?? makeRunVerify)({ repoChecks: () => checks, onFailedChecks });
+            gateOpts = { repoChecks: () => checks, onFailedChecks };
         }
         else if (read.problem !== "missing") {
             const why = read.problem === "malformed" ? "not a version 1 checks file" : "it could not be read";
@@ -371,6 +376,51 @@ export async function runHeadlessGo(argv, deps = {}) {
             writeErr(`Ignoring ${fixPath}: ${why}. The fix round runs the full pipeline.`);
         }
     }
+    // The gate's own checks, once on the clean tree before the build (YAG-1003),
+    // in the packages the approved plan names: what already failed there is a
+    // note, never a finding. Only a fresh build's tree is the clean base; a
+    // continuation or a fix round already carries a change, so it takes none.
+    let baseline;
+    const logBaseline = (data) => {
+        deps.logger?.("verify_baseline", data);
+        if (stream)
+            emit({ type: "pipeline_log", event: "verify_baseline", data });
+    };
+    // With a deadline, the baseline gets at most a sixth of the run's time left,
+    // and none below a minute: the build itself must still fit.
+    const deadlineLeftMs = budget?.deadlineMs === undefined ? undefined : budget.deadlineMs - (deps.now ?? Date.now)();
+    const baselineBudgetMs = deadlineLeftMs === undefined ? undefined : Math.floor(deadlineLeftMs / BASELINE_SHARE_OF_TIME_LEFT);
+    if (mission?.plan && !continuation && !fixRound && !deps.signal?.aborted) {
+        const dirs = baselineDirs(cwd, planPaths(mission.plan), readFile);
+        if (dirs.length > 0 && baselineBudgetMs !== undefined && baselineBudgetMs < MIN_BASELINE_BUDGET_MS) {
+            logBaseline({ skipped: "too little of the run's time left", deadlineLeftMs, baselineBudgetMs });
+        }
+        else if (dirs.length > 0) {
+            try {
+                const taken = await (deps.takeVerifyBaseline ?? makeTakeVerifyBaseline())(cwd, dirs, deps.signal, baselineBudgetMs);
+                logBaseline({ ran: taken.ran, failures: taken.failures, notes: taken.notes });
+                if (taken.baseline.size > 0)
+                    baseline = taken.baseline;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logBaseline({ error: message });
+                writeErr(`The verify baseline could not run (every failure counts): ${message}`);
+            }
+        }
+    }
+    // The last gate verdict's count of failures the clean tree already had, for the result.
+    let preexistingFailures = 0;
+    let runVerify;
+    if (gateOpts || baseline) {
+        const gate = (deps.makeRunVerify ?? makeRunVerify)({ ...gateOpts, ...(baseline ? { baseline } : {}) });
+        runVerify = async (verifyCwd, signal, baselinePaths) => {
+            const outcome = await gate(verifyCwd, signal, baselinePaths);
+            if (outcome.ran)
+                preexistingFailures = outcome.preexisting ?? 0;
+            return outcome;
+        };
+    }
     const pipelineDeps = {
         cwd,
         ...(fixRound ? { fixRound } : {}),
@@ -391,6 +441,7 @@ export async function runHeadlessGo(argv, deps = {}) {
         grounded: deps.grounded ?? grounding,
         ...(mission ? { mission } : {}),
         ...(runVerify ? { runVerify } : {}),
+        ...(baseline ? { runWorkstreamCheck: makeWorkstreamCheck({ baseline }) } : {}),
         ...(continuation ? { continuation: { stageAtStop: continuation.stageAtStop } } : {}),
         ...(resumeFrom ? { resumeFrom } : {}),
         onEvent: (ev, tag) => {
@@ -437,6 +488,7 @@ export async function runHeadlessGo(argv, deps = {}) {
             ...(args.runId ? { runId: args.runId } : {}),
             ...(tierCap ? { tierCap } : {}),
             ...(mission ? { missionMode: true } : {}),
+            preexistingFailures,
         });
         emit({ type: "pipeline_result", ...headless });
         return {

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

@@ -94,6 +94,8 @@ export interface VerifyOutcome {
     reason?: string;
     /** Critical findings parsed from a failing run; empty otherwise. */
     findings: Finding[];
+    /** Failures the clean tree already had (YAG-1003): named in `reason`, never findings. */
+    preexisting?: number;
 }
 /** Injectable fs seam so detection is unit-testable without a real repo. */
 export interface DetectOpts {
@@ -228,15 +230,16 @@ export type TestFailureClassification = {
  * Callers scrub the output through {@link scrubSecrets} BEFORE classification
  * so findings/notes never carry secrets (§0.9).
  */
-export declare function classifyTestFailure(output: string, exitCode: number): TestFailureClassification;
+export declare function classifyTestFailure(output: string, exitCode: number, limit?: number): TestFailureClassification;
 /**
  * Turn a failing verify run into `critical` Findings. A clean (exit 0) run yields
- * none. Located diagnostics (TypeScript first, then a generic file:line form) are
- * parsed into per-error findings; if none parse, a single capped finding carries
+ * none. Located diagnostics (TypeScript first, then a generic file:line form, then
+ * ESLint's stylish error rows under their file header) are parsed into per-error
+ * findings, at most `limit` of them; if none parse, a single capped finding carries
  * the tail of the output so the fix stage still gets actionable signal. Never
  * throws; always emits at least one finding on a non-zero exit.
  */
-export declare function parseVerifyFailures(output: string, exitCode: number, label: string): Finding[];
+export declare function parseVerifyFailures(output: string, exitCode: number, label: string, limit?: number): Finding[];
 /**
  * One finding's file as the REPO ROOT sees it.
  *
@@ -253,6 +256,49 @@ export declare function parseVerifyFailures(output: string, exitCode: number, la
  * so a finding that passes through twice is not double-prefixed.
  */
 export declare function toRepoRelativePath(file: string, repoRoot: string, commandCwd: string): string;
+/**
+ * What the gate's own checks already failed on before the build changed
+ * anything (YAG-1003): per command, how many times each failure key was seen
+ * on the clean tree. A command with no entry was not run there (or could not
+ * run), and its failures all count, as before.
+ */
+export type VerifyBaseline = ReadonlyMap<string, ReadonlyMap<string, number>>;
+/** One command's identity across the baseline run and the build's runs: where it runs and what it runs. */
+export declare function verifyCommandKey(command: Pick<VerifyCommand, "cwd" | "argv">): string;
+/**
+ * One failure's key, the shape #2601's `failureKeyOf` gives a CI failure: the
+ * repo-relative file and the message, never the line, since a change above a
+ * failure moves it. A failure that is only the output's tail names nothing
+ * stable, so it has no key and is never excused. Pure.
+ */
+export declare function verifyFailureKey(finding: Finding): string | null;
+/** How many times each failure key occurs. Pure. */
+export declare function failureKeyCounts(findings: readonly Finding[]): Map<string, number>;
+/**
+ * The failures this change caused: each failure key is excused at most as many
+ * times as the clean tree had it, so a second copy of an old error is new. A
+ * failure in a file the build did not touch still counts when the baseline did
+ * not have it, since a change can break another file's types. No baseline for
+ * the command leaves every failure in place. Pure.
+ */
+export declare function subtractBaseline(findings: readonly Finding[], baseline: ReadonlyMap<string, number> | undefined): {
+    findings: Finding[];
+    excused: number;
+};
+/** The note for failures the clean tree already had, by command label. Pure. */
+export declare function preexistingNote(byLabel: ReadonlyMap<string, number>): string | null;
+/**
+ * The repo-relative paths an approved plan names (`src/flows/a.tsx`,
+ * `packages/web/`), which say which packages the build will change before it
+ * has changed anything. URLs and paths that leave the tree are dropped. Pure.
+ */
+export declare function planPaths(plan: string): string[];
+/**
+ * The package dirs the baseline runs in: those the plan's paths fall in. The
+ * repo root drops out when a package below it was named, since its check is
+ * not one the build's gate would run then. Pure (the `readFile` seam).
+ */
+export declare function baselineDirs(repoRoot: string, paths: string[], readFile: (path: string) => string): string[];
 /** Result of actually executing the resolved command. */
 export interface VerifyExecResult {
     code: number;
@@ -352,6 +398,12 @@ export interface MakeRunVerifyOpts {
     treeStatus?: (cwd: string, signal?: AbortSignal) => Promise<string>;
     /** Undo what the half wrote into the tree (default: `git clean` / `git checkout` of exactly those paths). */
     undoTreeWrites?: (cwd: string, entries: TreeEntry[]) => Promise<void>;
+    /**
+     * What the typecheck and test halves already failed on before the build
+     * (YAG-1003, {@link makeTakeVerifyBaseline}). Those failures are a note, not
+     * findings. Absent: every failure is a finding, as before.
+     */
+    baseline?: VerifyBaseline | null;
 }
 /**
  * One workstream as the scoped checker sees it: the name its findings are
@@ -391,6 +443,8 @@ export interface MakeWorkstreamCheckOpts {
     detect?: (cwd: string, claimDirs: string[]) => VerifyCommand[];
     exec?: VerifyExec;
     timeoutMs?: number;
+    /** What the clean tree already failed on (YAG-1003): those failures are not a workstream's. */
+    baseline?: VerifyBaseline | null;
 }
 /**
  * The per-workstream scoped check the implement diamond runs right after the fan
@@ -428,5 +482,42 @@ export declare function makeWorkstreamCheck(opts?: MakeWorkstreamCheckOpts): (cw
  * blocks a real change on its own failure.
  */
 export declare function makeRunVerify(opts?: MakeRunVerifyOpts): (cwd: string, signal?: AbortSignal, baselinePaths?: string[]) => Promise<VerifyOutcome>;
+/** The whole baseline run's cap, before the build starts: it costs minutes at most. */
+export declare const VERIFY_BASELINE_BUDGET_MS: number;
+export interface MakeTakeVerifyBaselineOpts {
+    detect?: (cwd: string, dirs: string[]) => VerifyCommand[];
+    detectTests?: (cwd: string, dirs: string[]) => VerifyCommand[];
+    exec?: VerifyExec;
+    timeoutMs?: number;
+    testTimeoutMs?: number;
+    testEnv?: NodeJS.ProcessEnv;
+    budgetMs?: number;
+    now?: () => number;
+    treeStatus?: (cwd: string, signal?: AbortSignal) => Promise<string>;
+    undoTreeWrites?: (cwd: string, entries: TreeEntry[]) => Promise<void>;
+}
+/** What the baseline run found, for the gate and for the run's log. */
+export interface VerifyBaselineResult {
+    baseline: VerifyBaseline;
+    /** Commands that gave a verdict on the clean tree, by label. */
+    ran: string[];
+    /** Keyed failures the clean tree already had, across those commands. */
+    failures: number;
+    /** Commands that gave no verdict, and why: their failures all count later. */
+    notes: string[];
+}
+/**
+ * Run the gate's own typecheck and test commands ONCE on the clean tree,
+ * before the build changes anything (YAG-1003), in the package dirs the
+ * approved plan names, and keep each command's failure keys. The build's gate
+ * then counts only the failures this change added ({@link subtractBaseline}).
+ *
+ * The same detection, exec seam and environments as {@link makeRunVerify}, so
+ * a command's key and its failures' keys match the build's runs. Fail-open per
+ * command: one that cannot run, times out, or is not reached in the budget
+ * has no baseline, and its failures all count, as before. What the commands
+ * write into the tree is undone, so none of it reaches the candidate.
+ */
+export declare function makeTakeVerifyBaseline(opts?: MakeTakeVerifyBaselineOpts): (cwd: string, dirs: string[], signal?: AbortSignal, budgetOverrideMs?: number) => Promise<VerifyBaselineResult>;
 export {};
 //# sourceMappingURL=verify.d.ts.map

package/dist/extension/pipeline/verify.js

@@ -458,7 +458,7 @@ const FAILURE_SUMMARY = [
  * Callers scrub the output through {@link scrubSecrets} BEFORE classification
  * so findings/notes never carry secrets (§0.9).
  */
-export function classifyTestFailure(output, exitCode) {
+export function classifyTestFailure(output, exitCode, limit = MAX_LOCATED_FINDINGS) {
     if (exitCode === 0)
         return { kind: "clean" };
     const spawnInfra = classifyVerifyInfraFailure(output, exitCode);
@@ -521,7 +521,7 @@ export function classifyTestFailure(output, exitCode) {
         else if (!existing.file && parsed.file)
             byMessage.set(parsed.message, parsed);
     }
-    const failures = [...byMessage.values()].slice(0, MAX_LOCATED_FINDINGS);
+    const failures = [...byMessage.values()].slice(0, limit);
     if (failures.length > 0) {
         return {
             kind: "failures",
@@ -558,28 +558,45 @@ export function classifyTestFailure(output, exitCode) {
 const TS_DIAGNOSTIC = /^(.+?)\((\d+),\d+\):\s*error\s+TS\d+:\s*(.+)$/;
 /** Match a generic `path:line:col: error message` (eslint/tsc-pretty-ish). */
 const GENERIC_DIAGNOSTIC = /^(.+?):(\d+):\d+:?\s*(?:error\b[:\s]*)?(.+)$/;
+/** An ESLint stylish file header: one path with an extension, nothing else on the line. */
+const STYLISH_FILE = /^(?:\.{0,2}\/)?[^\s:]+\.[A-Za-z0-9]+$/;
+/** An ESLint stylish error row under that header: `12:5  error  message  rule`. */
+const STYLISH_ERROR = /^(\d+):\d+\s+(?:error|Error:)\s+(.+)$/;
 /**
  * Turn a failing verify run into `critical` Findings. A clean (exit 0) run yields
- * none. Located diagnostics (TypeScript first, then a generic file:line form) are
- * parsed into per-error findings; if none parse, a single capped finding carries
+ * none. Located diagnostics (TypeScript first, then a generic file:line form, then
+ * ESLint's stylish error rows under their file header) are parsed into per-error
+ * findings, at most `limit` of them; if none parse, a single capped finding carries
  * the tail of the output so the fix stage still gets actionable signal. Never
  * throws; always emits at least one finding on a non-zero exit.
  */
-export function parseVerifyFailures(output, exitCode, label) {
+export function parseVerifyFailures(output, exitCode, label, limit = MAX_LOCATED_FINDINGS) {
     if (exitCode === 0)
         return [];
     const located = [];
     const seen = new Set();
+    // ESLint's default (stylish) and `next lint` output name the file once, on
+    // its own line, above that file's `line:col  error  message  rule` rows.
+    let stylishFile;
     for (const raw of output.split("\n")) {
         const line = raw.trim();
         if (!line)
             continue;
         const m = line.match(TS_DIAGNOSTIC) ?? line.match(GENERIC_DIAGNOSTIC);
-        if (!m)
-            continue;
-        const file = m[1].trim();
-        const lineNo = Number(m[2]);
-        const message = m[3].trim();
+        let parts = m ? [m[1], m[2], m[3]] : null;
+        if (!parts) {
+            if (STYLISH_FILE.test(line)) {
+                stylishFile = line;
+                continue;
+            }
+            const row = stylishFile ? line.match(STYLISH_ERROR) : null;
+            if (!row || !stylishFile)
+                continue;
+            parts = [stylishFile, row[1], row[2].replace(/\s{2,}/g, " ")];
+        }
+        const file = parts[0].trim();
+        const lineNo = Number(parts[1]);
+        const message = parts[2].trim();
         // Guard the generic matcher against noise: require a plausible file token.
         if (!file || /\s/.test(file) || !Number.isFinite(lineNo))
             continue;
@@ -594,7 +611,7 @@ export function parseVerifyFailures(output, exitCode, label) {
             file,
             line: lineNo,
         });
-        if (located.length >= MAX_LOCATED_FINDINGS)
+        if (located.length >= limit)
             break;
     }
     if (located.length > 0)
@@ -651,6 +668,98 @@ function liftFinding(finding, repoRoot, commandCwd) {
     const file = toRepoRelativePath(finding.file, repoRoot, commandCwd);
     return file === finding.file ? finding : { ...finding, file };
 }
+/** One command's identity across the baseline run and the build's runs: where it runs and what it runs. */
+export function verifyCommandKey(command) {
+    return `${command.cwd}\u0000${command.argv.join(" ")}`;
+}
+/**
+ * One failure's key, the shape #2601's `failureKeyOf` gives a CI failure: the
+ * repo-relative file and the message, never the line, since a change above a
+ * failure moves it. A failure that is only the output's tail names nothing
+ * stable, so it has no key and is never excused. Pure.
+ */
+export function verifyFailureKey(finding) {
+    if (finding.message.includes("Output tail:"))
+        return null;
+    return `${finding.file ?? ""}\u0000${finding.message}`;
+}
+/** How many times each failure key occurs. Pure. */
+export function failureKeyCounts(findings) {
+    const counts = new Map();
+    for (const finding of findings) {
+        const key = verifyFailureKey(finding);
+        if (key !== null)
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * The failures this change caused: each failure key is excused at most as many
+ * times as the clean tree had it, so a second copy of an old error is new. A
+ * failure in a file the build did not touch still counts when the baseline did
+ * not have it, since a change can break another file's types. No baseline for
+ * the command leaves every failure in place. Pure.
+ */
+export function subtractBaseline(findings, baseline) {
+    if (!baseline)
+        return { findings: [...findings], excused: 0 };
+    const left = new Map(baseline);
+    const fresh = [];
+    let excused = 0;
+    for (const finding of findings) {
+        const key = verifyFailureKey(finding);
+        const count = key === null ? 0 : (left.get(key) ?? 0);
+        if (key !== null && count > 0) {
+            left.set(key, count - 1);
+            excused += 1;
+        }
+        else {
+            fresh.push(finding);
+        }
+    }
+    return { findings: fresh, excused };
+}
+/** The note for failures the clean tree already had, by command label. Pure. */
+export function preexistingNote(byLabel) {
+    const total = [...byLabel.values()].reduce((sum, n) => sum + n, 0);
+    if (total === 0)
+        return null;
+    const parts = [...byLabel].filter(([, n]) => n > 0).map(([label, n]) => `${label} ${n}`);
+    return `already failed before this change: ${total} (${parts.join(", ")}); not findings`;
+}
+/** Cap on the paths read off a plan, and on the packages the baseline runs in. */
+const MAX_PLAN_PATHS = 200;
+const MAX_BASELINE_PACKAGES = 10;
+/** A path-shaped token in plan prose: at least one `/`, no scheme. */
+const PLAN_PATH = /(?:^|[\s`'"(<[])(\.?\/?[\w@.+-]+(?:\/[\w@.+[\]-]+)+\/?)/g;
+/**
+ * The repo-relative paths an approved plan names (`src/flows/a.tsx`,
+ * `packages/web/`), which say which packages the build will change before it
+ * has changed anything. URLs and paths that leave the tree are dropped. Pure.
+ */
+export function planPaths(plan) {
+    const paths = new Set();
+    for (const match of plan.matchAll(PLAN_PATH)) {
+        const raw = match[1].replace(/[.,:;]+$/, "").replace(/^\.\//, "");
+        if (!raw || raw.startsWith("/") || raw.startsWith("..") || raw.includes("://"))
+            continue;
+        paths.add(raw);
+        if (paths.size >= MAX_PLAN_PATHS)
+            break;
+    }
+    return [...paths];
+}
+/**
+ * The package dirs the baseline runs in: those the plan's paths fall in. The
+ * repo root drops out when a package below it was named, since its check is
+ * not one the build's gate would run then. Pure (the `readFile` seam).
+ */
+export function baselineDirs(repoRoot, paths, readFile) {
+    const dirs = resolveClaimDirs(repoRoot, paths, readFile);
+    const root = normDir(repoRoot);
+    const below = dirs.filter((dir) => normDir(dir) !== root);
+    return (below.length > 0 ? below : dirs).slice(0, MAX_BASELINE_PACKAGES);
+}
 const SAFE_ENV_KEYS = [
     "PATH",
     "HOME",
@@ -815,6 +924,13 @@ export function makeDefaultExec(opts = {}) {
     });
 }
 const defaultExec = makeDefaultExec();
+/** The gate's typecheck-half detection, shared by the build's runs and the baseline run. */
+const defaultDetect = (cwd, changedDirs) => detectVerifyCommands(cwd, {
+    allowRepoOverride: process.env.YAGNI_CODE_ALLOW_VERIFY_OVERRIDE === "1",
+    changedDirs,
+});
+/** The gate's test-half detection, shared the same way. */
+const defaultDetectTests = (cwd, changedDirs) => detectVerifyTestCommands(cwd, { changedDirs });
 /**
  * A workstream's claims resolved to package dirs. Claims are PREFIXES and a claim
  * is very often a directory (`packages/backend/src/routes`), while
@@ -921,7 +1037,7 @@ export function makeWorkstreamCheck(opts = {}) {
                 anyRan = true;
                 labels.push(command.label);
                 if (run.code !== 0) {
-                    const parsed = parseVerifyFailures(run.output, run.code, command.label).map((f) => liftFinding(f, cwd, command.cwd));
+                    const parsed = subtractBaseline(parseVerifyFailures(run.output, run.code, command.label, Number.POSITIVE_INFINITY).map((f) => liftFinding(f, cwd, command.cwd)), opts.baseline?.get(verifyCommandKey(command))).findings.slice(0, MAX_LOCATED_FINDINGS);
                     const covered = parsed.filter((f) => f.file != null && target.files.some((claim) => claimCovers(claim, f.file)));
                     findings.push(...covered.map((f) => tagFinding(f, target.name)));
                     if (!uncoveredEmitted.has(memoKey)) {
@@ -952,13 +1068,8 @@ export function makeWorkstreamCheck(opts = {}) {
  * blocks a real change on its own failure.
  */
 export function makeRunVerify(opts = {}) {
-    const detect = opts.detect ??
-        ((cwd, changedDirs) => detectVerifyCommands(cwd, {
-            allowRepoOverride: process.env.YAGNI_CODE_ALLOW_VERIFY_OVERRIDE === "1",
-            changedDirs,
-        }));
-    const detectTests = opts.detectTests ??
-        ((cwd, changedDirs) => detectVerifyTestCommands(cwd, { changedDirs }));
+    const detect = opts.detect ?? defaultDetect;
+    const detectTests = opts.detectTests ?? defaultDetectTests;
     const changedDirs = opts.changedDirs ??
         (async (cwd, signal, baselinePaths) => {
             const snapshot = await snapshotWorkspace(cwd, signal);
@@ -1274,6 +1385,12 @@ export function makeRunVerify(opts = {}) {
         const findings = [];
         const reasons = [];
         let anyRan = false;
+        // Failures the clean tree already had, by command label (YAG-1003).
+        const preexisting = new Map();
+        const countPreexisting = (label, n) => {
+            if (n > 0)
+                preexisting.set(label, (preexisting.get(label) ?? 0) + n);
+        };
         // TYPECHECK HALF (frozen behavior, §0.2): run every changed package's build
         // check; union the findings. One package that cannot spawn fails OPEN (a
         // recorded reason, no finding) without sinking the verdict for the packages
@@ -1298,7 +1415,10 @@ export function makeRunVerify(opts = {}) {
                 anyRan = true;
                 typecheckLabels.push(command.label);
                 if (code !== 0) {
-                    findings.push(...parseVerifyFailures(output, code, command.label).map((f) => liftFinding(f, cwd, command.cwd)));
+                    const parsed = parseVerifyFailures(output, code, command.label, Number.POSITIVE_INFINITY).map((f) => liftFinding(f, cwd, command.cwd));
+                    const fresh = subtractBaseline(parsed, opts.baseline?.get(verifyCommandKey(command)));
+                    countPreexisting(command.label, fresh.excused);
+                    findings.push(...fresh.findings.slice(0, MAX_LOCATED_FINDINGS));
                 }
             }
             catch (err) {
@@ -1328,7 +1448,7 @@ export function makeRunVerify(opts = {}) {
                     try {
                         const { code, output: rawOutput } = await exec(command.argv, command.cwd, composed, testEnv);
                         const output = scrubSecrets(rawOutput);
-                        const cls = classifyTestFailure(output, code);
+                        const cls = classifyTestFailure(output, code, Number.POSITIVE_INFINITY);
                         if (cls.kind === "infra") {
                             reasons.push(`tests (${where}) could not run: ${cls.reason}; 'clean' reflects typecheck + review only`);
                             continue;
@@ -1343,7 +1463,9 @@ export function makeRunVerify(opts = {}) {
                         testLabels.push(command.label);
                         if (cls.kind === "failures") {
                             const room = Math.max(0, MAX_LOCATED_FINDINGS - testFindingCount);
-                            const take = cls.findings.slice(0, room).map((f) => liftFinding(f, cwd, command.cwd));
+                            const fresh = subtractBaseline(cls.findings.map((f) => liftFinding(f, cwd, command.cwd)), opts.baseline?.get(verifyCommandKey(command)));
+                            countPreexisting(command.label, fresh.excused);
+                            const take = fresh.findings.slice(0, room);
                             testFindingCount += take.length;
                             findings.push(...take);
                         }
@@ -1378,6 +1500,10 @@ export function makeRunVerify(opts = {}) {
                 findings.push(...repo.findings);
             }
         }
+        const note = preexistingNote(preexisting);
+        if (note)
+            reasons.push(note);
+        const preexistingTotal = [...preexisting.values()].reduce((sum, n) => sum + n, 0);
         // The command labels list only what produced a verdict — on every half —
         // so the FINISH trailer's `passed (<cmds>)` never claims a check that was
         // infra-skipped or threw (invariant §0.1).
@@ -1401,7 +1527,114 @@ export function makeRunVerify(opts = {}) {
             command,
             findings,
             ...(reasons.length ? { reason: reasons.join("; ") } : {}),
+            ...(preexistingTotal > 0 ? { preexisting: preexistingTotal } : {}),
         };
     };
 }
+/** The whole baseline run's cap, before the build starts: it costs minutes at most. */
+export const VERIFY_BASELINE_BUDGET_MS = 10 * 60_000;
+/**
+ * Run the gate's own typecheck and test commands ONCE on the clean tree,
+ * before the build changes anything (YAG-1003), in the package dirs the
+ * approved plan names, and keep each command's failure keys. The build's gate
+ * then counts only the failures this change added ({@link subtractBaseline}).
+ *
+ * The same detection, exec seam and environments as {@link makeRunVerify}, so
+ * a command's key and its failures' keys match the build's runs. Fail-open per
+ * command: one that cannot run, times out, or is not reached in the budget
+ * has no baseline, and its failures all count, as before. What the commands
+ * write into the tree is undone, so none of it reaches the candidate.
+ */
+export function makeTakeVerifyBaseline(opts = {}) {
+    const detect = opts.detect ?? defaultDetect;
+    const detectTests = opts.detectTests ?? defaultDetectTests;
+    const exec = opts.exec ?? defaultExec;
+    const now = opts.now ?? Date.now;
+    const treeStatus = opts.treeStatus ??
+        (async (cwd, signal) => (await snapshotWorkspace(cwd, signal)).status);
+    const undoTreeWrites = opts.undoTreeWrites ?? defaultUndoTreeWrites;
+    return async function takeVerifyBaseline(cwd, dirs, signal, budgetOverrideMs) {
+        const baseline = new Map();
+        const result = { baseline, ran: [], failures: 0, notes: [] };
+        if (dirs.length === 0)
+            return result;
+        const commands = detect(cwd, dirs);
+        const overridden = commands.some((c) => c.source === "override");
+        const tests = overridden ? [] : detectTests(cwd, dirs);
+        if (commands.length === 0 && tests.length === 0)
+            return result;
+        const startedAt = now();
+        const budgetMs = Math.min(opts.budgetMs ?? VERIFY_BASELINE_BUDGET_MS, budgetOverrideMs ?? Number.POSITIVE_INFINITY);
+        const before = await treeStatus(cwd, signal).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            result.notes.push(`could not read the tree before the baseline, so what it writes is not undone: ${scrubSecrets(msg)}`);
+            return null;
+        });
+        const runs = [
+            ...commands.map((command) => ({ command, test: false })),
+            ...tests.map((command) => ({ command, test: true })),
+        ];
+        try {
+            for (const { command, test } of runs) {
+                if (signal?.aborted)
+                    break;
+                const left = budgetMs - (now() - startedAt);
+                if (left < REPO_CHECK_MIN_START_MS) {
+                    result.notes.push(`${command.label} (${command.cwd}): not reached in the baseline budget`);
+                    continue;
+                }
+                const cap = Math.min(test
+                    ? (opts.testTimeoutMs ?? VERIFY_TEST_TIMEOUT_MS)
+                    : (opts.timeoutMs ?? VERIFY_TIMEOUT_MS), left);
+                const composed = composeAbortSignal(signal, AbortSignal.timeout(cap));
+                try {
+                    const { code, output: rawOutput } = test
+                        ? await exec(command.argv, command.cwd, composed, opts.testEnv ?? buildTestEnv())
+                        : await exec(command.argv, command.cwd, composed);
+                    const output = scrubSecrets(rawOutput);
+                    let failed;
+                    if (test) {
+                        const cls = classifyTestFailure(output, code, Number.POSITIVE_INFINITY);
+                        if (cls.kind === "infra" || cls.kind === "uncertain") {
+                            result.notes.push(`${command.label} (${command.cwd}): ${cls.kind === "infra" ? cls.reason : "output not interpretable"}`);
+                            continue;
+                        }
+                        failed = cls.kind === "failures" ? cls.findings : [];
+                    }
+                    else {
+                        const infra = code === 0 ? null : classifyVerifyInfraFailure(output, code);
+                        if (infra) {
+                            result.notes.push(`${command.label} (${command.cwd}): ${infra}`);
+                            continue;
+                        }
+                        failed = parseVerifyFailures(output, code, command.label, Number.POSITIVE_INFINITY);
+                    }
+                    const counts = failureKeyCounts(failed.map((f) => liftFinding(f, cwd, command.cwd)));
+                    baseline.set(verifyCommandKey(command), counts);
+                    result.ran.push(command.label);
+                    for (const n of counts.values())
+                        result.failures += n;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    result.notes.push(`${command.label} (${command.cwd}): could not run: ${scrubSecrets(msg)}`);
+                }
+            }
+        }
+        finally {
+            if (before !== null) {
+                try {
+                    const written = newTreeEntries(before, await treeStatus(cwd));
+                    if (written.length > 0)
+                        await undoTreeWrites(cwd, written);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    result.notes.push(`could not undo what the baseline wrote into the tree: ${scrubSecrets(msg)}`);
+                }
+            }
+        }
+        return result;
+    };
+}
 //# sourceMappingURL=verify.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.6-staging.1951.1",
+  "version": "1.2.6-staging.1952.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "0985f34f33f3c59e0fb7ed50af520abbcbb2466c"
+  "yagniSourceSha": "b25d4f380aa71b29777808fe149c71d8d0e3c4ce"
 }