tickmarkr 2.5.4 → 2.5.6

package/dist/gates/baseline.d.ts

@@ -31,12 +31,19 @@ export interface BaselineCommand {
     durationMs?: number;
     /** Sum of the per-file durations named by the runner; null when its output names none. */
     fileDurationSumMs?: number | null;
-    /** Total files reported by the runner summary; null when unavailable. */
+    /** Total files the runner would collect; null when unavailable. */
     fileCount?: number | null;
+    /** OBS-1044: `manifest` when `fileCount` came from the runner's own listing (test-manifest.ts's
+     * discovery seam) rather than a stdout summary sum. Absent on every pre-2.5.6 entry and on every
+     * scripted non-runner command, whose summary count keeps the stdout deficit rule byte-identically. */
+    fileCountSource?: "manifest";
     /** fileDurationSumMs / durationMs — average implied file concurrency, not a configured fork count. */
     impliedParallelism?: number | null;
     /** The slowest per-file entry named by the runner; null when per-file timing is unavailable. */
     longestFile?: BaselineFileDuration | null;
+    /** VL-1: every per-file duration the runner named, so a later per-file hang budget (test-manifest.ts)
+     * can be derived per file rather than from one slowest-file number; null when unavailable. */
+    fileDurations?: BaselineFileDuration[] | null;
     /** The ceiling that measurement implies, persisted so every later battery uses the same number. */
     ceilingMs?: number;
     /**
@@ -147,6 +154,9 @@ export declare function ceilingKillResult(gate: string, r: ShResult, ceilingMs:
  * shell asks it to finish faster than the thing it is measuring.
  */
 export declare const CAPTURE_CEILING_MS = 1800000;
+/** OBS-1044: a cached vitest entry whose count is a stdout sum may be inflated; only a manifest-derived
+ * count is safe to apply as a deficit floor. A null count compares nothing and is safe as-is. */
+export declare function staleFileCountCommands(baseline: Baseline, commands: Record<string, string>, cwd: string): string[];
 export declare function captureBaseline(cwd: string, commands: Record<string, string>): Promise<Baseline>;
 export interface VacuousOracleWarning {
     kind: "vacuous-oracle";
@@ -158,7 +168,10 @@ export declare function detectVacuousOracles(cwd: string, tasks: ReadonlyArray<{
     id: string;
     acceptance: AcceptanceItem[];
 }>): Promise<VacuousOracleWarning[]>;
-export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: {
+export interface RetryOptions {
+    authorizeRetry?: (cause: "infra" | "host-starved") => boolean;
+}
+export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: RetryOptions & {
     rerunOf?: HostStarvedRerun;
     infraRerun?: HostStarvedRerun;
     selected?: readonly string[];
@@ -182,7 +195,8 @@ interface CalmWindow {
 }
 export declare function setCalmWindowForTests(over: Partial<CalmWindow>): void;
 export declare function resetCalmWindowForTests(): void;
-export declare function waitForCalmWindow(): Promise<number>;
+export declare function calmWindowReady(): boolean;
+export declare function waitForCalmWindow(signal?: AbortSignal): Promise<number>;
 /** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */
 export declare function runnerFileCount(raw: string): number | null;
 export declare function fileCountDeficit(entry: BaselineCommand | undefined, raw: string, opts?: {

package/dist/gates/baseline.js

@@ -2,6 +2,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { availableParallelism, loadavg } from "node:os";
 import { join } from "node:path";
 import { DEFAULT_SHELL_TIMEOUT_MS, describeCapacity, sameCapacity, sh } from "../run/git.js";
+import { executionSignal } from "../run/execution-budget.js";
+import { isVitestTestCommand, manifestFileCount } from "./test-manifest.js";
 // incident #2 (run-20260709-104447): a vitest ✓ PASS line with "error" in the test NAME, wrapped in ANSI
 // codes that varied between baseline and worktree runs, was reported as a "new failure". Strip ANSI first;
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
@@ -230,13 +232,14 @@ function fileTiming(output, wallClockMs) {
             files.push({ file: match[1], durationMs });
     }
     if (!files.length)
-        return { fileDurationSumMs: null, impliedParallelism: null, longestFile: null };
+        return { fileDurationSumMs: null, impliedParallelism: null, longestFile: null, fileDurations: null };
     const fileDurationSumMs = files.reduce((sum, entry) => sum + entry.durationMs, 0);
     const longestFile = files.reduce((longest, entry) => entry.durationMs > longest.durationMs ? entry : longest);
     return {
         fileDurationSumMs,
         impliedParallelism: wallClockMs > 0 ? fileDurationSumMs / wallClockMs : null,
         longestFile,
+        fileDurations: files,
     };
 }
 // A failing command whose output holds no shape any runner here names. The marker is content-free and
@@ -463,6 +466,27 @@ const invalidCaptureEntry = (durationMs, invalidCause, invalidatingLines = []) =
     ceilingMs: effectiveCeilingMs({ durationMs }),
     ...(invalidatingLines.length ? { invalidatingLines } : {}),
 });
+// OBS-1044: a vitest command's count is the manifest discovery seam's (the same listing the gate
+// asks the report to certify), never a sum of every summary line in stdout — tests that spawn
+// nested runners echo their own summaries through the filter and inflated a baseline by two files,
+// so any diff that changed the nested echo read as a deficit. The listing is a collection, not a
+// run: the suite still runs exactly once here. Any other command keeps the stdout sum.
+const captureFileCount = async (cwd, cmd, raw) => {
+    if (!isVitestTestCommand(cmd, cwd))
+        return { fileCount: runnerFileCount(raw) };
+    const fileCount = await manifestFileCount(cmd, cwd);
+    return fileCount === null ? { fileCount } : { fileCount, fileCountSource: "manifest" };
+};
+/** OBS-1044: a cached vitest entry whose count is a stdout sum may be inflated; only a manifest-derived
+ * count is safe to apply as a deficit floor. A null count compares nothing and is safe as-is. */
+export function staleFileCountCommands(baseline, commands, cwd) {
+    return Object.entries(commands)
+        .filter(([name, cmd]) => {
+        const entry = baseline.commands[name];
+        return entry?.fileCount != null && entry.fileCountSource !== "manifest" && isVitestTestCommand(cmd, cwd);
+    })
+        .map(([name]) => name);
+}
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
@@ -494,7 +518,7 @@ export async function captureBaseline(cwd, commands) {
             console.error(`tickmarkr: baseline capture for "${name}" was killed at its ${CAPTURE_CEILING_MS}ms ceiling — `
                 + `it recorded NO fingerprints, so nothing is forgiven and every gate will treat a pre-existing `
                 + `failure as a fresh one. Raise the ceiling or shorten the command.`);
-            base.commands[name] = { ...invalidCaptureEntry(durationMs, "ceiling-kill"), fileCount: runnerFileCount(raw) };
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "ceiling-kill"), ...await captureFileCount(cwd, cmd, raw) };
             continue;
         }
         // Run 2137: the child exited and printed ordinary FAIL/AssertionError lines, so the gate-side
@@ -508,7 +532,7 @@ export async function captureBaseline(cwd, commands) {
                 + `it recorded NO exit-code verdict and NO fingerprints, so nothing is forgiven for this command; `
                 + `the measurement cannot distinguish a pre-existing failure from one caused by exhaustion. `
                 + `First invalidating line: ${invalidatingLines[0]}`);
-            base.commands[name] = { ...invalidCaptureEntry(durationMs, "resource-exhaustion", invalidatingLines), fileCount: runnerFileCount(raw) };
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "resource-exhaustion", invalidatingLines), ...await captureFileCount(cwd, cmd, raw) };
             continue;
         }
         // OBS-966: a worker RPC timeout is infra even beside an all-green summary.
@@ -516,7 +540,7 @@ export async function captureBaseline(cwd, commands) {
         const runnerVerdict = classifyRunnerOutput(raw, r.code);
         if (runnerVerdict === "infra") {
             console.error(`tickmarkr: baseline capture for "${name}" carries runner-infrastructure evidence — it recorded NO verdict; nothing is forgiven for this command`);
-            base.commands[name] = { ...invalidCaptureEntry(durationMs, "infra", withoutVitestEchoBlocks(combinedOutput).filter((line) => isInfraLine(line.replace(ANSI_RE, "")))), fileCount: runnerFileCount(raw) };
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "infra", withoutVitestEchoBlocks(combinedOutput).filter((line) => isInfraLine(line.replace(ANSI_RE, "")))), ...await captureFileCount(cwd, cmd, raw) };
             continue;
         }
         base.commands[name] = {
@@ -528,7 +552,7 @@ export async function captureBaseline(cwd, commands) {
             missingCommand: missingConfiguredCommand(cmd, r),
             durationMs,
             ...fileTiming(raw, durationMs),
-            fileCount: runnerFileCount(raw),
+            ...await captureFileCount(cwd, cmd, raw),
             ceilingMs: effectiveCeilingMs({ durationMs }),
             // T7: the world this measurement was taken in, so a later reader can ask whether its own world
             // is the same one. Recorded from THIS command's own shell result, never re-derived here.
@@ -614,7 +638,10 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // T7: every verdict below carries the capacity ITS OWN command ran under, taken off the shell
         // result rather than re-derived after the fact. The skip row above ran no command and therefore
         // states no capacity — a row that never divided the machine must not claim that it did.
+        let recoveryBlocked;
         const record = (g) => {
+            if (recoveryBlocked)
+                g = { ...g, meta: { ...g.meta, recoveryBlocked } };
             const withReap = r.reapedGroup ? { ...g, meta: { ...g.meta, reapedGroup: true } } : g;
             const withReapError = r.reapError ? { ...withReap, meta: { ...withReap.meta, reapError: r.reapError } } : withReap;
             const withRerun = rerunOf ? {
@@ -696,19 +723,37 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // retain the whole-output read so a repeated infra abort can never be baseline-forgiven as green.
         const classification = classifyFreshRunnerOutput(entry, raw, r.code);
         if (name === "test" && classification === "infra" && !rerunOf && !opts.infraRerun) {
-            const waitedMs = await waitForCalmWindow();
-            const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance }));
-            continue;
+            const waitedMs = await waitForCalmWindow(executionSignal());
+            if (opts.authorizeRetry && !calmWindowReady()) {
+                recoveryBlocked = "calm window unavailable within the existing wait ceiling";
+            }
+            else if (opts.authorizeRetry && !opts.authorizeRetry("infra")) {
+                recoveryBlocked = "infrastructure retry allowance exhausted or subject unavailable";
+            }
+            else {
+                const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
+                results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance }));
+                continue;
+            }
         }
         // OBS-896: every fresh failure must be timeout-class, and the suite must take at least twice its
         // own baseline measurement. The first read buys one calm rerun here, never a worker repair.
         if (name === "test" && classification !== "infra" && failing.length && !rerunOf && !opts.infraRerun
             && hostStarved(failing.join("\n"), r.durationMs ?? 0, entry?.durationMs)) {
-            const waitedMs = await waitForCalmWindow();
-            const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance }));
-            continue;
+            const waitedMs = await waitForCalmWindow(executionSignal());
+            if (opts.authorizeRetry && !calmWindowReady()) {
+                recoveryBlocked = "calm window unavailable within the existing wait ceiling";
+            }
+            else if (opts.authorizeRetry && !opts.authorizeRetry("host-starved")) {
+                recoveryBlocked = "verification retry allowance exhausted or subject unavailable";
+            }
+            else {
+                // Compatibility with OBS-896, not an infrastructure reclassification: a persistent
+                // timeout remains the ordinary conservative verdict after the single bounded remeasure.
+                const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
+                results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance }));
+                continue;
+            }
         }
         if (classification === "infra") {
             const evidence = failing.length
@@ -826,11 +871,14 @@ const DEFAULT_CALM = {
 let calm = DEFAULT_CALM;
 export function setCalmWindowForTests(over) { calm = { ...calm, ...over }; }
 export function resetCalmWindowForTests() { calm = DEFAULT_CALM; }
-export async function waitForCalmWindow() {
+export function calmWindowReady() { return calm.loadProvider() <= calm.calmLoad(); }
+export async function waitForCalmWindow(signal) {
     const started = Date.now();
     while (calm.loadProvider() > calm.calmLoad() && Date.now() - started < calm.maxWaitMs) {
-        await new Promise((resolve) => setTimeout(resolve, calm.pollMs));
+        signal?.throwIfAborted();
+        await new Promise((resolve) => setTimeout(resolve, signal ? Math.min(calm.pollMs, 100) : calm.pollMs));
     }
+    signal?.throwIfAborted();
     return Date.now() - started;
 }
 /** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */

package/dist/gates/cache.d.ts

@@ -0,0 +1,101 @@
+import type { Baseline } from "./baseline.js";
+import type { GateResult } from "./types.js";
+import { type RunCapacity, type VerificationProtocol } from "../run/git.js";
+export declare const DEFAULT_VERDICT_CACHE_BOUND = 128;
+export declare function setVerdictCacheBoundForTests(bound: number | undefined): void;
+export declare function resetVerdictCacheBoundForTests(): void;
+export declare const LOCKFILES: readonly ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"];
+export declare function lockfileHash(worktree: string): string;
+export declare function canonicalJson(obj: unknown): string;
+export declare function baselineIdentity(baseline?: Baseline): string;
+export declare function getWorktreeTree(worktree: string): Promise<string>;
+export interface GateEnvironmentInput {
+    nodeRuntime?: string;
+    lockfile?: string;
+    worktree?: string;
+    capacity?: RunCapacity;
+    selectedSet?: readonly string[];
+    scope?: VerificationScope;
+    /** R41: the verification protocol + runner lifecycle policy; defaults to this process's. */
+    verification?: VerificationProtocol;
+}
+export interface EnvironmentParts {
+    nodeRuntime: string;
+    lockfile: string;
+    capacity: RunCapacity;
+    selectedSet?: readonly string[];
+    verification: VerificationProtocol;
+}
+export declare function environmentFingerprint(env: GateEnvironmentInput): {
+    fingerprint: string;
+    parts: EnvironmentParts;
+};
+export type VerificationScope = "battery" | "tip" | "standalone";
+export interface VerificationIdentity {
+    /** the gate the verdict answers — build/lint/test may share one command and are still three verdicts */
+    gate?: string;
+    /** which verifier produced it: a battery gate row or an integration-tip row (own report, own forgiveness rule) */
+    scope?: VerificationScope;
+    /** Checkout location is diagnostic metadata; equal trees share verdicts across worktrees. */
+    worktree?: string;
+    tree: string;
+    command: string;
+    baseline: string;
+    environment: string;
+    envParts?: EnvironmentParts;
+}
+export declare function computeVerificationIdentity(params: {
+    worktree: string;
+    gate: string;
+    scope?: VerificationScope;
+    command: string;
+    baseline?: Baseline;
+    selectedSet?: readonly string[];
+    capacity?: RunCapacity;
+    tree?: string;
+    lockfile?: string;
+    nodeRuntime?: string;
+    verification?: VerificationProtocol;
+}): Promise<VerificationIdentity | undefined>;
+export declare function verificationIdentityKey(id: VerificationIdentity): string;
+export declare function formatReusedDetails(originalDetails: string, id: VerificationIdentity): string;
+export interface CachedVerdict {
+    gate: string;
+    pass: boolean;
+    details: string;
+    exitCode?: number;
+    meta?: Record<string, unknown>;
+    capacity?: RunCapacity;
+}
+export declare function formatReusedRow(cached: CachedVerdict, id: VerificationIdentity): GateResult;
+export declare function reusedIdentity(id: VerificationIdentity): Record<string, unknown>;
+export declare function isInfraResult(result: GateResult | {
+    meta?: Record<string, unknown>;
+    details?: string;
+    cause?: string;
+    exitCode?: number;
+}): boolean;
+export declare function resolveStateDir(worktree: string, artifactDir?: string): string;
+export declare function resolveVerdictStoreDir(stateDir: string): string;
+export interface StoredVerdictRecord {
+    key: string;
+    identity: VerificationIdentity;
+    verdict: CachedVerdict;
+    timestamp: number;
+    sequence: number;
+}
+export declare function resetGlobalStoreSequenceForTests(): void;
+export declare class VerdictStore {
+    readonly dir: string;
+    constructor(dir: string);
+    private initSequenceFromDisk;
+    private static unknownPolicy;
+    get(id?: VerificationIdentity): CachedVerdict | undefined;
+    set(id: VerificationIdentity | undefined, verdict: GateResult | CachedVerdict): boolean;
+    size(): number;
+    clear(): void;
+    evictOldest(bound?: number): number;
+}
+export declare function getVerdictStore(stateDir: string, options?: {
+    bound?: number;
+}): VerdictStore;