tickmarkr 2.5.4 → 2.5.5

package/dist/gates/run-gates.js

@@ -6,15 +6,17 @@ import { TIER_RANK } from "../config/config.js";
 import { getAdapter } from "../adapters/registry.js";
 import { GATE_NAMES } from "../graph/schema.js";
 import { acceptanceGate } from "./acceptance.js";
-import { compareToBaseline } from "./baseline.js";
+import { compareToBaseline, effectiveCeilingMs } from "./baseline.js";
 import { evidenceGate } from "./evidence.js";
 import { captureLlmOutput } from "./llm.js";
 import { disallowedBy } from "../route/preference.js";
 import { marginalCostRank } from "../route/router.js";
 import { gateReviewerFloor, pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
-import { shGit } from "../run/git.js";
+import { evaluateManifestedTest, isVitestTestCommand } from "./test-manifest.js";
+import { shGit, resolvedCapacity } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
+import { computeVerificationIdentity, formatReusedRow, getVerdictStore, isInfraResult, resolveStateDir, reusedIdentity, } from "./cache.js";
 const productionLoadProvider = () => loadavg()[0] ?? 0;
 let loadProvider = productionLoadProvider;
 /** Test seam — inject deterministic load samples; production always reads os.loadavg. */
@@ -192,9 +194,45 @@ export function testCommandForFiles(testCmd, files) {
     const fwd = wrapped && !/\s--\s/.test(testCmd) ? " --" : "";
     return `${testCmd}${fwd} ${files.map(shq).join(" ")}`;
 }
+/** The manifest-report path for a detected vitest test command — never the stdout-count/file-count path. */
+async function runVitestManifestGate(worktree, cmd, baseline, selected, artifactDir) {
+    const entry = baseline.commands.test;
+    const outcome = await evaluateManifestedTest(cmd, worktree, {
+        baselineDurations: entry?.fileDurations,
+        longestFile: entry?.longestFile,
+        overallCeilingMs: effectiveCeilingMs(entry),
+        artifactDir,
+    });
+    const reportPath = outcome.reportPath;
+    return {
+        gate: "test",
+        pass: outcome.pass,
+        details: outcome.details,
+        meta: { ...outcome.meta, reportPath, ...(selected ? { selectedTests: [...selected] } : {}) },
+    };
+}
+const SIGNAL_EXIT_RE = /\b(?:SIGTERM|SIGKILL|signal\s+(?:9|15)|exit(?:s|ed|\s+code)?\s+(?:137|143))\b/i;
+const FAILURE_IDENTITY_RE = /\b(?:AssertionError|FAIL\s+\S|Tests?\s+\d+\s+failed|expected\s+.+\s+to\s+)\b/i;
+/** D1: apply the daemon's signal-only rider before either battery cache read or write. Its onGate
+ * classification happens after persistence, too late to keep a scripted runner's non-verdict out.
+ * Keep named failures as work verdicts and preserve details for failure-policy fingerprinting. */
+function classifySignalOnlyTest(g) {
+    if (g.gate !== "test" || g.pass || g.meta?.infra === true || !SIGNAL_EXIT_RE.test(g.details))
+        return;
+    const named = Array.isArray(g.meta?.failingTests) && g.meta.failingTests.length > 0;
+    if (named || FAILURE_IDENTITY_RE.test(g.details))
+        return;
+    g.meta = { ...g.meta, classification: "infra", infra: true, retryable: false, kind: "signal-exit" };
+}
 export async function runGates(task, ctx) {
     const results = [];
     let commits = [];
+    const stateDir = ctx.stateDir ?? resolveStateDir(ctx.worktree, ctx.artifactDir);
+    const verdictStore = getVerdictStore(stateDir);
+    // VC-1: a reused verdict is journaled as its own row (the daemon appends every note by name) so
+    // the ledger names the reuse and the identity even where the gate-result row's details must stay
+    // the fresh verdict's (see formatReusedRow).
+    const noteReuse = (gate, r, id) => ctx.onGate?.({ phase: "note", gate, name: "gate-reused-verdict", payload: { gate, pass: r.pass, details: r.meta?.reusedDetails, ...reusedIdentity(id) }, result: r });
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
@@ -359,7 +397,7 @@ export async function runGates(task, ctx) {
     const runBattery = async (commands, selected, gates = toolGates) => {
         if (!gates.length)
             return;
-        if (!v185) {
+        if (!v185 && !(commands.test && isVitestTestCommand(commands.test, ctx.worktree))) {
             // ponytail: compareToBaseline batches adjacent tools — their starts are emitted at iteration,
             // not at true execution start. They are collectively sub-second (measured), so the debounce
             // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
@@ -386,25 +424,60 @@ export async function runGates(task, ctx) {
         // any later tool before anyone reads its verdict.
         for (const g of gates) {
             await emitStart(g);
-            const [r] = await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], g === "test" && selected ? { selected } : {}));
+            const cmd = commands[g];
+            let r;
+            let cached = false;
+            let identity;
+            if (cmd !== undefined) {
+                identity = await computeVerificationIdentity({
+                    worktree: ctx.worktree,
+                    gate: g,
+                    scope: ctx.verificationScope,
+                    command: cmd,
+                    baseline: ctx.baseline,
+                    selectedSet: g === "test" ? selected : undefined,
+                    capacity: resolvedCapacity(),
+                });
+                const hit = verdictStore.get(identity);
+                if (hit)
+                    classifySignalOnlyTest(hit); // Older entries predate classification at the write seam.
+                if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+                    r = formatReusedRow(hit, identity);
+                    cached = true;
+                    await noteReuse(g, r, identity);
+                }
+            }
+            if (!r) {
+                // VL-1: a detected vitest test command is judged by its own invocation-bound report — the
+                // stdout-count/file-count path (compareToBaseline's fileCountDeficit) never runs for it. Any
+                // other scripted test command keeps today's exit-code contract byte-identically.
+                const useManifest = g === "test" && commands.test !== undefined && isVitestTestCommand(commands.test, ctx.worktree);
+                r = useManifest
+                    ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir))
+                    : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], g === "test" && selected ? { selected } : {})))[0];
+            }
             // the screen's interval IS the test gate's first interval, so the split needs no second clock
             if (g === "test" && selected)
-                selectedDurationMs = spans.get("test").durationMs;
+                selectedDurationMs = spans.get("test")?.durationMs ?? 0;
             // The pre-battery check proves the tree clean ONCE; a command that exits 0 having rewritten a
             // tracked file makes it dirty again, and every gate after it — including the next shell gate,
             // which would then run against bytes HEAD does not hold — inherits that. So re-check after each
             // command, the last one included, and fail the gate whose command did it. (A red command needs
             // no check: it already ends the round, and its own output is the truer verdict.)
-            if (r.pass && commands[g]) {
+            if (!cached && r.pass && commands[g]) {
                 const dirt = await dirtyWorktree();
                 if (dirt) {
                     await record(dirtyRefusal(g, dirt, commands[g]));
                     return;
                 }
             }
+            if (r)
+                classifySignalOnlyTest(r);
+            if (!cached && identity && r && !isInfraResult(r)) {
+                verdictStore.set(identity, { ...r, meta: { ...r.meta, source: "gate", runDir: ctx.artifactDir } });
+            }
             if (g === "test" && selected) {
                 const screened = { ...r, meta: { ...r.meta, selectedTests: selected } };
-                // green: held (see heldTest) so the full suite below can supersede it with ONE verdict.
                 if (!screened.pass)
                     await record(screened);
                 else {
@@ -748,9 +821,43 @@ export async function runGates(task, ctx) {
         // This is the last shell command a round can run — the judge's named-test oracle (acceptance.ts)
         // may have run one before it, and every gate between the battery and here reads commits only, so
         // a clean tree HERE is what makes "the gated commit is the tested tree" true at merge time.
-        const [full] = await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"]));
-        fullDurationMs = spans.get("test").durationMs - (selectedDurationMs ?? 0);
-        const dirt = full.pass ? await dirtyWorktree() : undefined;
+        // VL-1: the merge-candidate's manifest is the FULL set — a full suite whose report lacks one
+        // manifest file never reaches the pass branch below, so a selected-only green can never merge.
+        let full;
+        let cached = false;
+        let identity;
+        if (ctx.commands.test !== undefined) {
+            identity = await computeVerificationIdentity({
+                worktree: ctx.worktree,
+                gate: "test",
+                scope: ctx.verificationScope,
+                command: ctx.commands.test,
+                baseline: ctx.baseline,
+                selectedSet: undefined,
+                capacity: resolvedCapacity(),
+            });
+            const hit = verdictStore.get(identity);
+            if (hit)
+                classifySignalOnlyTest(hit);
+            if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+                full = formatReusedRow(hit, identity);
+                cached = true;
+                await noteReuse("test", full, identity);
+            }
+        }
+        if (!full) {
+            const fullUsesManifest = ctx.commands.test !== undefined && isVitestTestCommand(ctx.commands.test, ctx.worktree);
+            full = fullUsesManifest
+                ? await measure("test", () => runVitestManifestGate(ctx.worktree, ctx.commands.test, ctx.baseline, undefined, ctx.artifactDir))
+                : (await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"])))[0];
+        }
+        fullDurationMs = spans.get("test") ? spans.get("test").durationMs - (selectedDurationMs ?? 0) : 0;
+        const dirt = (!cached && full.pass) ? await dirtyWorktree() : undefined;
+        if (full)
+            classifySignalOnlyTest(full);
+        if (!cached && identity && full && !dirt && !isInfraResult(full)) {
+            verdictStore.set(identity, { ...full, meta: { ...full.meta, source: "gate", runDir: ctx.artifactDir } });
+        }
         const merged = withTelemetry(dirt
             ? dirtyRefusal("test", dirt, ctx.commands.test)
             : { ...full, meta: { ...full.meta, fullSuite: true, selectedTests: selected } });

package/dist/gates/test-manifest.d.ts

@@ -0,0 +1,99 @@
+import type { BaselineFileDuration } from "./baseline.js";
+export declare function isVitestTestCommand(cmd: string, cwd: string): boolean;
+/** One identity for every path this module compares: repo-relative, forward-slash. `vitest list
+ * --json` and `TestModule.moduleId` both hand back an absolute filesystem path already resolved
+ * through any symlink in it (e.g. macOS's `/var` -> `/private/var`, under which every OS temp dir —
+ * and so every test fixture worktree — lives); `cwd` as tickmarkr holds it may not be. Resolving cwd
+ * before computing the relative path is what makes the two actually comparable. Manifests built from
+ * a selected-test screen are already repo-relative and pass through unchanged. */
+export declare function toManifestPath(file: string, cwd: string): string;
+export interface TestReportCompletion {
+    at: number;
+    status: "passed" | "failed";
+    /** Failure fingerprints for this file; absent/empty on a passed file. */
+    failures?: string[];
+}
+/** The runner's own machine report — requested/started/completed are the runner's claims about ITSELF. */
+export interface TestReport {
+    nonce: string;
+    requested: string[];
+    started: Record<string, number>;
+    completed: Record<string, TestReportCompletion>;
+    /** Files the reporter observed complete MORE than once — `completed`'s object keys cannot show
+     * this themselves (a second write silently overwrites the first), so the reporter records the
+     * evidence separately before it is lost. */
+    duplicateCompletions?: string[];
+    /** Written last, once, when the runner reaches its own terminal state. Its absence means the run
+     * never certified completion — killed, crashed, or still in flight — and is never a verdict. */
+    certificate?: {
+        at: number;
+        exitCode: number;
+    };
+}
+/** Reads and structurally validates the report; a missing or malformed file is `undefined` — never a partial parse. */
+export declare function readTestReport(path: string): TestReport | undefined;
+export type ManifestVerdictKind = "pass" | "infra" | "work" | "fail-closed";
+export interface ManifestVerdict {
+    kind: ManifestVerdictKind;
+    pass: boolean;
+    details: string;
+    meta: Record<string, unknown>;
+}
+/**
+ * The independent validator: given the manifest THIS invocation was asked to prove, its bound nonce
+ * and the independently observed process exit code, decide the
+ * verdict from the report alone. `killedFile` short-circuits every report-shaped check — a job this
+ * module killed for a per-file hang never reaches its report.
+ */
+export declare function verifyManifestReport(opts: {
+    manifest: readonly string[];
+    nonce: string;
+    exitCode: number | undefined;
+    report: TestReport | undefined;
+    killedFile?: string;
+    hangBudgetMs?: number;
+}): ManifestVerdict;
+/** How much longer than its baseline measurement one file may legitimately run before it is a hang. */
+export declare const FILE_HANG_SLACK = 3;
+export declare const DEFAULT_FILE_HANG_BUDGET_MS = 60000;
+export declare function fileHangBudgetMs(file: string, baselineDurations?: readonly BaselineFileDuration[] | null, ceilingMs?: number, longestFile?: BaselineFileDuration | null): number;
+export interface ManifestRunResult {
+    exitCode: number | undefined;
+    stdout: string;
+    stderr: string;
+    report: TestReport | undefined;
+    killedFile?: string;
+    hangBudgetMs?: number;
+    /** The child's own pid (its process GROUP id too, since it is spawned detached) — for a caller
+     * that wants to prove the group is really gone after a hang kill (`process.kill(-pid, 0)` throws). */
+    pid?: number;
+}
+/** Supervise the configured command and poll the runner's atomic lifecycle snapshots. Every
+ * timeout kills the detached process group, including descendants holding the output pipes. */
+export declare function runManifestedTest(cmd: string, cwd: string, opts: {
+    manifest: readonly string[];
+    nonce: string;
+    reportPath: string;
+    env?: NodeJS.ProcessEnv;
+    baselineDurations?: readonly BaselineFileDuration[] | null;
+    longestFile?: BaselineFileDuration | null;
+    pollMs?: number;
+    overallCeilingMs?: number;
+}): Promise<ManifestRunResult>;
+export interface ManifestGateOutcome {
+    pass: boolean;
+    kind: ManifestVerdictKind;
+    details: string;
+    classification?: "infra" | "regression";
+    meta: Record<string, unknown>;
+    exitCode: number;
+    reportPath: string;
+}
+/** One configured runner execution, and its own collection under the same arguments and environment.
+ * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */
+export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
+    baselineDurations?: readonly BaselineFileDuration[] | null;
+    longestFile?: BaselineFileDuration | null;
+    overallCeilingMs?: number;
+    artifactDir?: string;
+}): Promise<ManifestGateOutcome>;