@yagni-app/code-staging 1.2.7-staging.2022.1 → 1.2.7-staging.2027.1

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

@@ -74,7 +74,7 @@ import { snapshotWorkspace } from "./workspace.js";
 import type { WorktreeExec } from "./worktree.js";
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
-import { makeRunVerify, type VerifyBaselineResult } from "./verify.js";
+import { makeMeasureChecksOnBase, 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. */
@@ -181,6 +181,8 @@ export interface HeadlessGoDeps {
      * there is none). Defaults to the real gate; injected in tests.
      */
     makeRunVerify?: typeof makeRunVerify;
+    /** The approved checks' run on the unchanged code (`measureOnBase`). Defaults to the real one; injected in tests. */
+    measureChecksOnBase?: ReturnType<typeof makeMeasureChecksOnBase>;
     /** 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. */

package/dist/extension/pipeline/headlessGo.js

@@ -85,7 +85,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 { PipelineStageError, runPipeline as defaultRunPipeline, } from "./orchestrator.js";
-import { baselineDirs, makeRunVerify, makeTakeVerifyBaseline, makeWorkstreamCheck, parseChangedPaths, planPaths, } from "./verify.js";
+import { baselineDirs, makeMeasureChecksOnBase, makeRunVerify, makeTakeVerifyBaseline, makeWorkstreamCheck, parseChangedPaths, planPaths, } from "./verify.js";
 import { loadGroundingEnabled } from "../grounding.js";
 import { codeStateHome } from "../stateHome.js";
 import { parseTierCap, TIER_CAP_ENV } from "./tierCap.js";
@@ -451,42 +451,90 @@ export async function runHeadlessGo(argv, deps = {}) {
     // the baseline there would excuse the attempt's own breakage). It then leans
     // on `checks.json`, whose base standing the host took on the real base.
     let baseline;
-    const logBaseline = (data) => {
-        deps.logger?.("verify_baseline", data);
+    const logPipeline = (event, data) => {
+        deps.logger?.(event, data);
         if (stream)
-            emit({ type: "pipeline_log", event: "verify_baseline", data });
+            emit({ type: "pipeline_log", event, data });
+    };
+    // A measurement before the build (the baseline, the plan's checks on the
+    // base) gets at most a sixth of the run's time left when it starts, and
+    // none below a minute: the build itself must still fit. No deadline, no cap.
+    const preBuildShare = () => {
+        const leftMs = budget?.deadlineMs === undefined ? undefined : budget.deadlineMs - (deps.now ?? Date.now)();
+        const shareMs = leftMs === undefined ? undefined : Math.floor(leftMs / BASELINE_SHARE_OF_TIME_LEFT);
+        return {
+            leftMs,
+            shareMs,
+            tooLittle: shareMs !== undefined && shareMs < MIN_BASELINE_BUDGET_MS,
+        };
     };
-    // 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({
+        const share = preBuildShare();
+        if (dirs.length > 0 && share.tooLittle) {
+            logPipeline("verify_baseline", {
                 skipped: "too little of the run's time left",
-                deadlineLeftMs,
-                baselineBudgetMs,
+                deadlineLeftMs: share.leftMs,
+                baselineBudgetMs: share.shareMs,
             });
         }
         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 });
+                const taken = await (deps.takeVerifyBaseline ?? makeTakeVerifyBaseline())(cwd, dirs, deps.signal, share.shareMs);
+                logPipeline("verify_baseline", {
+                    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 });
+                logPipeline("verify_baseline", { error: message });
                 writeErr(`The verify baseline could not run (every failure counts): ${message}`);
             }
         }
     }
+    // The approved plan's checks the host has not seen pass on the unchanged
+    // code (`measureOnBase`), each run once there before the build, on the same
+    // fresh tree the baseline above reads: a check that already failed there is
+    // not this change's to fix. A continuation or a fix round carries a change,
+    // so it measures nothing; its host hands it what an earlier session found.
+    let checksOnBase;
+    const measureFile = gateOpts?.repoChecks?.() ?? null;
+    if (measureFile?.checks.some((check) => check.measureOnBase) &&
+        !continuation &&
+        !fixRound &&
+        !deps.signal?.aborted) {
+        const share = preBuildShare();
+        if (share.tooLittle) {
+            logPipeline("verify_checks_on_base", {
+                skipped: "too little of the run's time left",
+                leftMs: share.leftMs,
+                shareMs: share.shareMs,
+            });
+        }
+        else {
+            try {
+                const measured = await (deps.measureChecksOnBase ?? makeMeasureChecksOnBase())(cwd, measureFile, deps.signal, share.shareMs);
+                logPipeline("verify_checks_on_base", {
+                    ran: measured.ran,
+                    passed: [...measured.passed],
+                    failed: [...measured.failed.keys()],
+                    notes: measured.notes,
+                    treeUndone: measured.treeUndone,
+                });
+                if (measured.passed.size > 0 || measured.failed.size > 0)
+                    checksOnBase = measured;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logPipeline("verify_checks_on_base", { error: message });
+                writeErr(`The approved checks could not run on the unchanged code (each keeps its checks.json standing): ${message}`);
+            }
+        }
+    }
     // The last gate verdict's count of failures the clean tree already had, for the result.
     let preexistingFailures = 0;
     let runVerify;
@@ -506,6 +554,7 @@ export async function runHeadlessGo(argv, deps = {}) {
         const made = (deps.makeRunVerify ?? makeRunVerify)({
             ...gateOpts,
             ...(baseline ? { baseline } : {}),
+            ...(checksOnBase ? { checksOnBase } : {}),
             ...(scan ? { scanChange: scan } : {}),
             ...(cloud ? { unreadTestFailureIsFinding: true } : {}),
         });

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

@@ -21,6 +21,12 @@ export interface MissionCheck {
     command: string;
     status: MissionCheckStatus;
     cause?: string;
+    /**
+     * The host has not seen it pass on the unchanged code (an approved plan's
+     * check): the session runs it there once before the build, and what that
+     * measures stands over `status` (`makeMeasureChecksOnBase` in verify.ts).
+     */
+    measureOnBase?: boolean;
 }
 export interface MissionCiStep {
     name: string;

package/dist/extension/pipeline/missionChecks.js

@@ -91,7 +91,10 @@ function parseJob(value) {
             return null;
         if (failed.step !== undefined && !isString(failed.step))
             return null;
-        job.failedCheck = { name: failed.name, ...(isString(failed.step) ? { step: failed.step } : {}) };
+        job.failedCheck = {
+            name: failed.name,
+            ...(isString(failed.step) ? { step: failed.step } : {}),
+        };
     }
     return job;
 }
@@ -131,6 +134,8 @@ export function parseMissionChecksFile(text) {
         const check = { command: raw.command, status: raw.status };
         if (isString(raw.cause))
             check.cause = raw.cause;
+        if (raw.measureOnBase === true)
+            check.measureOnBase = true;
         checks.push(check);
     }
     const ciJobs = [];

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

@@ -108,6 +108,18 @@ export interface VerifyOutcome {
 }
 /** An approved check's name on the report: its command, cut at 80 characters. */
 export declare function checkLabel(command: string): string;
+/**
+ * A command as the gate compares two: the same words, whatever spaces sit
+ * between them, and a package manager's script named the one way it runs,
+ * so `yarn test` and `yarn run test`, `npm test` and `npm run test`, `pnpm
+ * lint` and `pnpm run lint` are one check, run once (staging bench
+ * 2026-10-25: the gate's own `test` script and two approved twins ran one
+ * suite three times). Only the leading form: a manager's flags before the
+ * script leave the command as it is. The same rule as
+ * `canonicalCheckCommand` in the backend's attempts/inputs.ts; both test
+ * files read one corpus, test/fixtures/equivalentCheckCommands.json. Pure.
+ */
+export declare function canonicalCheckCommand(command: string): string;
 /**
  * True when a command changes the checkout's git state: a commit, a branch
  * created or switched, a reset, a stash, a push. `git branch`, `git remote`
@@ -455,6 +467,13 @@ export interface MakeRunVerifyOpts {
      * findings. Absent: every failure is a finding, as before.
      */
     baseline?: VerifyBaseline | null;
+    /**
+     * What the approved checks `checks.json` marks `measureOnBase` did on the
+     * unchanged code ({@link makeMeasureChecksOnBase}). It stands over each
+     * one's `status`: one that passed there must pass, and one that failed
+     * there is the change's only where it fails anew. Absent: `status` alone.
+     */
+    checksOnBase?: ChecksOnBase | null;
     /**
      * The cloud session's rule (spec decision 3): a test run that exits
      * non-zero with output no parser reads is a finding carrying its output
@@ -584,5 +603,59 @@ export interface VerifyBaselineResult {
  * 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>;
+/**
+ * What the approved checks marked `measureOnBase` did on the unchanged code,
+ * by command (trimmed): each that passed there, and each that failed there
+ * with failures the gate reads, with how often each failure key was seen
+ * (none for a failure only a summary line names). A command in neither gave
+ * no verdict there, and keeps the status `checks.json` gave it.
+ */
+export interface ChecksOnBase {
+    passed: ReadonlySet<string>;
+    failed: ReadonlyMap<string, ReadonlyMap<string, number>>;
+}
+/** {@link ChecksOnBase}, with what ran and why the rest gave no verdict, for the run's log. */
+export interface ChecksOnBaseResult extends ChecksOnBase {
+    ran: string[];
+    notes: string[];
+    /**
+     * What the checks wrote into the tree was undone (or they wrote nothing).
+     * False when the tree could not be read before them or the undo failed:
+     * the build then starts on a tree the checks may have dirtied.
+     */
+    treeUndone: boolean;
+}
+/** The whole measurement's cap, before the build starts: the approved plan's own checks, once each. */
+export declare const CHECKS_ON_BASE_BUDGET_MS: number;
+export interface MakeMeasureChecksOnBaseOpts {
+    exec?: VerifyExec;
+    /** Repository-checks env override for determinism in tests (default: the gate's own). */
+    repoChecksEnv?: NodeJS.ProcessEnv;
+    toolchain?: () => ToolchainFile | null;
+    /** One check's cap (default {@link REPO_CHECK_TIMEOUT_MS}). */
+    timeoutMs?: number;
+    budgetMs?: number;
+    now?: () => number;
+    treeStatus?: (cwd: string, signal?: AbortSignal) => Promise<string>;
+    undoTreeWrites?: (cwd: string, entries: TreeEntry[]) => Promise<void>;
+}
+/**
+ * Run each approved check `checks.json` marks `measureOnBase` once on the
+ * unchanged code, before the build changes anything: a plan's check the
+ * host has not seen pass there (none of the record's, or a red one the
+ * record may hold from long ago). A check the plan wrote for the change
+ * often fails there by design (its test file is not written yet), and a
+ * failure that says only that (a file not found, no tests to run, output no
+ * parser reads) is no verdict: its failures all count after the build, as
+ * before. A failure the gate reads (failing tests, located diagnostics, a
+ * test runner's failure summary) is one the unchanged code already has.
+ *
+ * Run as the gate runs the check ({@link makeRunVerify}): the same command
+ * line, environment and toolchain, from the repository root, so a failure
+ * keys the same on both trees. Bounded: each check by its cap, the whole by
+ * the budget, and one not reached in it has no verdict. What the checks
+ * write into the tree is undone.
+ */
+export declare function makeMeasureChecksOnBase(opts?: MakeMeasureChecksOnBaseOpts): (cwd: string, file: MissionChecksFile, signal?: AbortSignal, budgetOverrideMs?: number) => Promise<ChecksOnBaseResult>;
 export {};
 //# sourceMappingURL=verify.d.ts.map

package/dist/extension/pipeline/verify.js

@@ -111,6 +111,44 @@ const VERIFY_LENS = "does_it_hold";
 export function checkLabel(command) {
     return command.length > 80 ? `${command.slice(0, 77)}...` : command;
 }
+/**
+ * Package-manager words that are the manager's own command, never a script:
+ * `yarn add`, `pnpm install`. Any other word after `yarn` or `pnpm` runs the
+ * script of that name, as `run` does.
+ */
+const YARN_COMMANDS = new Set("add audit autoclean bin cache check config constraints create dedupe dlx exec explain generate-lock-entry global help import info init install licenses link list login logout node npm outdated owner pack patch patch-commit plugin policies publish rebuild remove run set stage tag team unlink unplug up upgrade upgrade-interactive version versions why workspace workspaces".split(" "));
+const PNPM_COMMANDS = new Set("add audit bin cache cat-file cat-index config create dedupe deploy dlx doctor env exec fetch find-hash i import init install install-test it licenses link list ln ls outdated pack patch patch-commit patch-remove prune publish rb rebuild recursive remove rm root run self-update server setup store un uninstall unlink up update why".split(" "));
+/** The scripts npm runs without `run`: its lifecycle shorthands. */
+const NPM_SCRIPT_SHORTHANDS = new Set(["test", "start", "stop", "restart"]);
+/**
+ * A command as the gate compares two: the same words, whatever spaces sit
+ * between them, and a package manager's script named the one way it runs,
+ * so `yarn test` and `yarn run test`, `npm test` and `npm run test`, `pnpm
+ * lint` and `pnpm run lint` are one check, run once (staging bench
+ * 2026-10-25: the gate's own `test` script and two approved twins ran one
+ * suite three times). Only the leading form: a manager's flags before the
+ * script leave the command as it is. The same rule as
+ * `canonicalCheckCommand` in the backend's attempts/inputs.ts; both test
+ * files read one corpus, test/fixtures/equivalentCheckCommands.json. Pure.
+ */
+export function canonicalCheckCommand(command) {
+    const words = command.trim().split(/\s+/).filter(Boolean);
+    const [manager, next, ...rest] = words;
+    const script = /^[A-Za-z0-9][\w:.@/-]*$/;
+    if (manager === "npm" || manager === "yarn" || manager === "pnpm") {
+        const runs = next === "run" || (manager === "npm" && next === "run-script");
+        if (runs && rest[0] && script.test(rest[0]))
+            return [manager, "run", ...rest].join(" ");
+        const shorthand = next !== undefined &&
+            script.test(next) &&
+            (manager === "npm"
+                ? NPM_SCRIPT_SHORTHANDS.has(next)
+                : !(manager === "yarn" ? YARN_COMMANDS : PNPM_COMMANDS).has(next));
+        if (shorthand)
+            return [manager, "run", next, ...rest].join(" ");
+    }
+    return words.join(" ");
+}
 /** Git subcommands that only read: a check may run them as often as it likes. */
 const READ_ONLY_GIT = new Set("status diff log show ls-files ls-tree rev-parse rev-list check-ignore grep blame describe cat-file shortlog diff-tree merge-base for-each-ref show-ref name-rev count-objects var version help".split(" "));
 /**
@@ -1139,6 +1177,38 @@ export function makeWorkstreamCheck(opts = {}) {
         return results;
     };
 }
+/**
+ * A failing repository command's findings, located from the folder it ran in
+ * and prefixed with what ran: the gate's on the build's tree, and the
+ * unchanged code's measurement ({@link makeMeasureChecksOnBase}), so a failure
+ * keys the same on both. Pure.
+ */
+function repoCommandFindings(failure, at) {
+    const limit = at.limit ?? MAX_LOCATED_FINDINGS;
+    const cls = classifyTestFailure(failure.output, failure.code, limit);
+    const parsed = cls.kind === "failures"
+        ? cls.findings
+        : parseVerifyFailures(failure.output, failure.code, at.label, limit);
+    return parsed.map((f) => ({
+        ...liftFinding(f, at.repoRoot, at.dir),
+        message: `${at.prefix}: ${f.message}`,
+    }));
+}
+/** What an approved check's failure is prefixed with, on the build's tree and on the unchanged code. */
+const approvedPrefix = (label) => `approved check \`${label}\``;
+/**
+ * An approved check's standing on the unchanged code. What the session
+ * measured there stands over what the host handed it: a red the record kept
+ * may be stale.
+ */
+function measuredBaseline(onBase, check) {
+    const command = check.command.trim();
+    if (onBase?.failed.has(command))
+        return "fails_on_base";
+    if (onBase?.passed.has(command))
+        return "runnable";
+    return check.status;
+}
 /**
  * Build the runVerify function injected into the orchestrator. It discovers the
  * changed package(s) (scoped to this run's diff via `baselinePaths`), detects a
@@ -1292,7 +1362,7 @@ export function makeRunVerify(opts = {}) {
         });
         try {
             await runApprovedChecks(run, approved);
-            await runCiSteps(run, steps, new Set(file.checks.map((check) => check.command.trim())));
+            await runCiSteps(run, steps, new Set(file.checks.map((check) => canonicalCheckCommand(check.command))));
         }
         finally {
             // Whatever ran (an aborted half included) is what the host reads. A half
@@ -1329,15 +1399,19 @@ export function makeRunVerify(opts = {}) {
         const startedAt = now();
         try {
             const { code, output: rawOutput } = await exec(repoCheckArgv(command), dir, composed, env);
-            const record = (baseline, note) => run.checks.push({
-                name: check.name,
-                command,
-                cwd: relative(run.cwd, dir) || ".",
-                exitCode: note ? null : code,
-                durationMs: now() - startedAt,
-                baseline,
-                ...(note ? { note } : {}),
-            });
+            const record = (baseline, note) => {
+                const entry = {
+                    name: check.name,
+                    command,
+                    cwd: relative(run.cwd, dir) || ".",
+                    exitCode: note ? null : code,
+                    durationMs: now() - startedAt,
+                    baseline,
+                    ...(note ? { note } : {}),
+                };
+                run.checks.push(entry);
+                return entry;
+            };
             if (code === 0) {
                 record(check.baseline);
                 return { kind: "passed" };
@@ -1349,8 +1423,7 @@ export function makeRunVerify(opts = {}) {
                 record("cannot_run", `${reason}; ${exitSummary(check.name, code, output)}`);
                 return { kind: "note", reason };
             }
-            record(check.baseline);
-            return { kind: "failed", output, code };
+            return { kind: "failed", output, code, record: record(check.baseline) };
         }
         catch (err) {
             run.checks.push({
@@ -1368,14 +1441,7 @@ export function makeRunVerify(opts = {}) {
     }
     /** A failure's findings, located from the folder the command ran in and prefixed with what ran. */
     function repoFailureFindings(run, failure, label, prefix, dir) {
-        const cls = classifyTestFailure(failure.output, failure.code);
-        const parsed = cls.kind === "failures"
-            ? cls.findings
-            : parseVerifyFailures(failure.output, failure.code, label);
-        return parsed.map((f) => ({
-            ...liftFinding(f, run.cwd, dir),
-            message: `${prefix}: ${f.message}`,
-        }));
+        return repoCommandFindings(failure, { label, prefix, repoRoot: run.cwd, dir });
     }
     const findingRoom = (run) => Math.max(0, MAX_LOCATED_FINDINGS - run.findings.length);
     /**
@@ -1398,22 +1464,42 @@ export function makeRunVerify(opts = {}) {
                 run.reasons.push(`approved check \`${label}\` not run: it changes the checkout's git state (a branch, a commit or a reset), which a check must never do`);
                 continue;
             }
+            // The failures it had there, when the session measured it failing.
+            const failedOnBase = opts.checksOnBase?.failed.get(check.command.trim());
+            const status = measuredBaseline(opts.checksOnBase, check);
             const verdict = await runRepoCommand(run, check.command, run.cwd, undefined, {
                 name: label,
-                baseline: check.status,
+                baseline: status,
             });
             if (verdict.kind === "failed")
-                run.approvedFailed.add(check.command.trim());
+                run.approvedFailed.add(canonicalCheckCommand(check.command));
             if (verdict.kind === "note") {
                 run.reasons.push(`approved check \`${label}\` ${verdict.reason}`);
             }
-            else if (verdict.kind === "failed" && check.status === "fails_on_base") {
+            else if (verdict.kind === "failed" && failedOnBase) {
+                // Only what the unchanged code did not already fail is this change's.
+                // A failure no parser reads is excused only when the unchanged code's
+                // was unread too (a summary line, as PHPUnit prints); after readable
+                // failures there, it says the change broke the run itself.
+                const found = repoFailureFindings(run, verdict, label, approvedPrefix(label), run.cwd);
+                const fresh = subtractBaseline(found, failedOnBase).findings.filter((finding) => failedOnBase.size > 0 || verifyFailureKey(finding) !== null);
+                if (fresh.length === 0) {
+                    run.reasons.push(`approved check \`${label}\` failed as it did on the unchanged code before the build; not this change's`);
+                }
+                else {
+                    // Its record reads as the change's failure, for the host too.
+                    verdict.record.baseline = "runnable";
+                    run.labels.push(label);
+                    run.findings.push(...fresh.slice(0, findingRoom(run)));
+                }
+            }
+            else if (verdict.kind === "failed" && status === "fails_on_base") {
                 run.reasons.push(`approved check \`${label}\` failed, and it already failed on the unchanged code; the host compares the two after the build`);
             }
             else {
                 run.labels.push(label);
                 if (verdict.kind === "failed") {
-                    const found = repoFailureFindings(run, verdict, label, `approved check \`${label}\``, run.cwd);
+                    const found = repoFailureFindings(run, verdict, label, approvedPrefix(label), run.cwd);
                     run.findings.push(...found.slice(0, findingRoom(run)));
                 }
             }
@@ -1450,8 +1536,8 @@ export function makeRunVerify(opts = {}) {
                 return;
             if (stoppedJobs.has(job))
                 continue;
-            if (approvedCommands.has(step.run.trim())) {
-                if (run.approvedFailed.has(step.run.trim()))
+            if (approvedCommands.has(canonicalCheckCommand(step.run))) {
+                if (run.approvedFailed.has(canonicalCheckCommand(step.run)))
                     settle(job, "failed");
                 else
                     stepPassed(job);
@@ -1602,8 +1688,20 @@ export function makeRunVerify(opts = {}) {
             else {
                 const testEnv = opts.testEnv ?? buildTestEnv();
                 let testFindingCount = 0;
+                // A root test script an approved check runs too (`yarn run test`
+                // beside `yarn test`) runs once, as that check, on the repository's
+                // toolchain: the staging bench (2026-10-25) ran one suite as both and
+                // read two verdicts of it.
+                const approvedTwins = new Set((repoFile?.checks ?? [])
+                    .filter((check) => check.status !== "cannot_run")
+                    .map((check) => canonicalCheckCommand(check.command)));
                 for (const command of testCommands) {
                     const where = basename(command.cwd) || command.cwd;
+                    const line = command.argv.join(" ");
+                    if (relative(cwd, command.cwd) === "" && approvedTwins.has(canonicalCheckCommand(line))) {
+                        reasons.push(`tests (${where}): \`${line}\` runs once, as the approved check it is`);
+                        continue;
+                    }
                     const composed = composeAbortSignal(signal, AbortSignal.timeout(testTimeoutMs));
                     const startedAt = now();
                     try {
@@ -1847,4 +1945,115 @@ export function makeTakeVerifyBaseline(opts = {}) {
         return result;
     };
 }
+/** The whole measurement's cap, before the build starts: the approved plan's own checks, once each. */
+export const CHECKS_ON_BASE_BUDGET_MS = 10 * 60_000;
+/**
+ * Run each approved check `checks.json` marks `measureOnBase` once on the
+ * unchanged code, before the build changes anything: a plan's check the
+ * host has not seen pass there (none of the record's, or a red one the
+ * record may hold from long ago). A check the plan wrote for the change
+ * often fails there by design (its test file is not written yet), and a
+ * failure that says only that (a file not found, no tests to run, output no
+ * parser reads) is no verdict: its failures all count after the build, as
+ * before. A failure the gate reads (failing tests, located diagnostics, a
+ * test runner's failure summary) is one the unchanged code already has.
+ *
+ * Run as the gate runs the check ({@link makeRunVerify}): the same command
+ * line, environment and toolchain, from the repository root, so a failure
+ * keys the same on both trees. Bounded: each check by its cap, the whole by
+ * the budget, and one not reached in it has no verdict. What the checks
+ * write into the tree is undone.
+ */
+export function makeMeasureChecksOnBase(opts = {}) {
+    const exec = opts.exec ?? defaultExec;
+    const now = opts.now ?? Date.now;
+    const toolchain = opts.toolchain ??
+        (() => {
+            const path = process.env.YAGNI_TOOLCHAIN_FILE?.trim();
+            return path ? readToolchainFile(path) : null;
+        });
+    const treeStatus = opts.treeStatus ??
+        (async (cwd, signal) => (await snapshotWorkspace(cwd, signal)).status);
+    const undoTreeWrites = opts.undoTreeWrites ?? defaultUndoTreeWrites;
+    return async function measureChecksOnBase(cwd, file, signal, budgetOverrideMs) {
+        const passed = new Set();
+        const failed = new Map();
+        const result = { passed, failed, ran: [], notes: [], treeUndone: true };
+        const targets = file.checks.filter((check) => check.measureOnBase === true &&
+            check.status !== "cannot_run" &&
+            !changesGitState(check.command));
+        if (targets.length === 0)
+            return result;
+        const startedAt = now();
+        const budgetMs = Math.min(opts.budgetMs ?? CHECKS_ON_BASE_BUDGET_MS, budgetOverrideMs ?? Number.POSITIVE_INFINITY);
+        const env = opts.repoChecksEnv ?? buildRepoCheckEnv(process.env, toolchain());
+        const before = await treeStatus(cwd, signal).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            result.treeUndone = false;
+            result.notes.push(`could not read the tree before the checks, so what they write is not undone: ${scrubSecrets(msg)}`);
+            return null;
+        });
+        try {
+            for (const check of targets) {
+                if (signal?.aborted)
+                    break;
+                const command = check.command.trim();
+                const label = checkLabel(check.command);
+                const left = budgetMs - (now() - startedAt);
+                if (left < REPO_CHECK_MIN_START_MS) {
+                    result.notes.push(`\`${label}\`: not reached in the budget`);
+                    continue;
+                }
+                const composed = composeAbortSignal(signal, AbortSignal.timeout(Math.min(opts.timeoutMs ?? REPO_CHECK_TIMEOUT_MS, left)));
+                try {
+                    const { code, output: rawOutput } = await exec(repoCheckArgv(check.command), cwd, composed, env);
+                    if (code === 0) {
+                        passed.add(command);
+                        result.ran.push(label);
+                        continue;
+                    }
+                    const output = scrubSecrets(rawOutput);
+                    const cls = classifyTestFailure(output, code, Number.POSITIVE_INFINITY);
+                    if (cls.kind === "infra") {
+                        result.notes.push(`\`${label}\`: could not run: ${cls.reason}`);
+                        continue;
+                    }
+                    const found = repoCommandFindings({ output, code }, {
+                        label,
+                        prefix: approvedPrefix(label),
+                        repoRoot: cwd,
+                        dir: cwd,
+                        limit: Number.POSITIVE_INFINITY,
+                    });
+                    // Output no parser reads says nothing of what failed (a test file
+                    // the change writes, not there yet): no verdict.
+                    if (cls.kind === "uncertain" && found.every((f) => verifyFailureKey(f) === null)) {
+                        result.notes.push(`\`${label}\`: exited ${code} with output no parser reads`);
+                        continue;
+                    }
+                    failed.set(command, failureKeyCounts(found));
+                    result.ran.push(label);
+                }
+                catch (err) {
+                    result.notes.push(`\`${label}\`: ${unexitedNote(err, signal, composed)}`);
+                }
+            }
+        }
+        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.treeUndone = false;
+                    result.notes.push(`could not undo what the checks 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.7-staging.2022.1",
+  "version": "1.2.7-staging.2027.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": "a1987aec00c09173fc5632921272940eac896c8e"
+  "yagniSourceSha": "1dd7310c6a9ff69891182d936aa792a4d375970b"
 }