tickmarkr 2.6.4 → 2.6.6

package/dist/gates/run-gates.js

@@ -15,6 +15,7 @@ import { marginalCostRank } from "../route/router.js";
 import { carriedAuthorVendors, gateReviewerFloor, pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
 import { discoverTestManifest, evaluateManifestedTest, isVitestTestCommand, VITEST_CACHE_ENV, worktreeVitestCache } from "./test-manifest.js";
+import { RUNNER_INFRA_DIAGNOSTIC_RE, timeoutShaped } from "./timeout-shaped.js";
 import { executionSignal } from "../run/execution-budget.js";
 import { failureDisposition } from "../run/recovery.js";
 import { dependencyLinkRefusal, FORK_CAP_ENV, preserveWorktree, producerFields, ROUTING_ENV_SEAMS, shGit, resolvedCapacity, SUITE_PARENT_ENV, verificationProtocol } from "../run/git.js";
@@ -253,7 +254,13 @@ async function listFullManifest(cmd, worktree) {
         rmSync(dir, { recursive: true, force: true });
     }
 }
-/** The manifest-report path for a detected vitest test command — never the stdout-count/file-count path. */
+/** The manifest-report path for a detected vitest test command — never the stdout-count/file-count path.
+ * ONE outer latch (`retried`) buys at most one more measurement of the exact same selection: the bounded
+ * infrastructure retry, or — v2.6.6 C (D-873), default-on — a behavioral timeout red carrying runner
+ * infra diagnostics, read by the daemon's own predicate (timeout-shaped.ts). Either waits for calm and
+ * spends the bounded allowance when one is configured; neither follows a receipt-backed recovery
+ * (retryable:false) or a diagnostic re-observation, and the second sample never stacks the stranded
+ * single-fork recovery. The second sample is authoritative; the first keeps its receipts beside it. */
 async function runVitestManifestGate(worktree, cmd, baseline, selected, artifactDir, retry = {}, retried = false) {
     const entry = baseline.commands.test;
     const outcome = await evaluateManifestedTest(cmd, worktree, {
@@ -263,21 +270,28 @@ async function runVitestManifestGate(worktree, cmd, baseline, selected, artifact
         artifactDir,
         evidence: retry.evidence,
         retryBaseCommand: retry.retryBaseCommand, // OBS-1166: the un-narrowed command for a selected screen's stranded retry
+        allowStrandedRecovery: !retried,
     });
     const reportPath = outcome.reportPath;
     const evidence = { evidenceReceipt: outcome.evidenceReceipt, evidenceReceipts: outcome.evidenceReceipts };
-    if (!retried && retry.authorizeRetry && failureDisposition(outcome) === "infrastructure"
-        && outcome.meta?.retryable !== false) {
+    const disposition = failureDisposition(outcome);
+    const shaped = disposition === "behavioral" && timeoutShaped(outcome.details) && RUNNER_INFRA_DIAGNOSTIC_RE.test(outcome.details);
+    if (!retried && outcome.meta?.retryable !== false && retry.retryBaseCommand !== REOBSERVATION_RETRY_BASE
+        && (shaped || (retry.authorizeRetry && disposition === "infrastructure"))) {
         const waitedMs = await waitForCalmWindow(executionSignal());
         if (!calmWindowReady())
             return { ...evidence, gate: "test", pass: false, details: outcome.details,
                 meta: { ...outcome.meta, reportPath, recoveryBlocked: "calm window unavailable within the existing wait ceiling" } };
-        if (!retry.authorizeRetry("infra")) {
+        if (retry.authorizeRetry && !retry.authorizeRetry("infra")) {
             return { ...evidence, gate: "test", pass: false, details: outcome.details,
                 meta: { ...outcome.meta, reportPath, recoveryBlocked: "infrastructure retry allowance exhausted or subject unavailable" } };
         }
         const result = await runVitestManifestGate(worktree, cmd, baseline, selected, artifactDir, retry, true);
-        return { ...result, evidenceReceipts: [...(outcome.evidenceReceipts ?? []), ...(result.evidenceReceipts ?? [])], meta: { ...result.meta, runnerInfraRerun: { count: 1, waitedMs, firstReportPath: reportPath } } };
+        const rerun = { count: 1, waitedMs, firstReportPath: reportPath };
+        return { ...result, evidenceReceipts: [...(outcome.evidenceReceipts ?? []), ...(result.evidenceReceipts ?? [])],
+            meta: { ...result.meta, ...(shaped
+                    ? { remeasured: { ...rerun, first: { pass: outcome.pass, details: outcome.details, meta: outcome.meta } } }
+                    : { runnerInfraRerun: rerun }) } };
     }
     return {
         ...evidence,
@@ -290,7 +304,8 @@ async function runVitestManifestGate(worktree, cmd, baseline, selected, artifact
 /** A retry base no runner invocation parses. evaluateManifestedTest builds its stranded single-fork
  * retry from the base it is handed, and one it cannot parse throws before any spawn — so this base
  * disables that inner recovery: a worker-RPC-stranded re-observation comes back infra (the caller
- * parks it as ambiguous) instead of launching a second execution. */
+ * parks it as ambiguous) instead of launching a second execution. runVitestManifestGate reads it as
+ * the mark of a diagnostic subset, which never buys the outer timeout-shaped remeasurement either. */
 export const REOBSERVATION_RETRY_BASE = "tickmarkr-reobservation-refuses-stranded-retry";
 /** OBS-1106 residual: ONE isolated re-observation of a timeout-shaped red's attributed failing files on
  * the same checkout, narrowed exactly as a screen is. Never cached and never a verdict: the caller
@@ -467,16 +482,28 @@ export async function runGates(task, ctx) {
     };
     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);
     // T4 (OBS-265): a GREEN selected-test run is a screen, not the round's verdict — the merge-candidate
     // round re-runs the full suite on the same commit and THAT is what the round reports. With no
     // semantic gate to act on it, the screen is held so its full suite speaks for it in one row.
     // (A RED screen IS the verdict: the round ends there, so it is recorded immediately.)
     let heldTest;
+    const semantic = enabled("acceptance") || enabled("review");
+    // v2.6.5 T6 (D): the closed repair-mode table. A repair the REVIEW sent back (carried review:material)
+    // whose test history is clean — selection allowed, no required repair test — asks the question it
+    // was sent back for first: cheap gates → acceptance ‖ review → screen → merge-candidate full suite,
+    // so a semantic red costs zero test starts. selectTests false or a nonempty requiredRepairTests is a
+    // test-red repair and keeps battery-first order; so does every first attempt (nothing carried).
+    const semanticFirst = semantic && ctx.selectTests === true && !ctx.requiredRepairTests?.length
+        && (ctx.carriedFindings ?? []).some((f) => f.class === "review:material");
+    // Semantic-first, a review that returned NO verdict is not a red that ends the round before its
+    // test proof: the daemon re-asks only the review (runReviewRecovery) and merges on the rows beside
+    // it, so the round still buys its screen and full suite. The row stays red; the round is unsatisfied.
+    const failed = () => results.some((r) => !r.pass && !(semanticFirst && r.gate === "review" && r.meta?.noVerdict === true));
     // OBS-1176: when acceptance/review WILL act on a green screen, the screen is published before they
     // start, as its own selected row. The full suite afterwards is a second invocation on its own row —
     // it carries only its own receipts and interval, so it neither erases nor re-counts the screen.
-    const publishScreen = enabled("acceptance") || enabled("review");
+    // Semantic-first, nothing acts on the screen but its full suite: it is held like a gate-less round's.
+    const publishScreen = semantic && !semanticFirst;
     // v2.0 T2 (OBS-554): this round's per-gate measurement. Every interval a gate actually spends
     // executing is added HERE, at the call site that runs it, so a gate that runs twice (the test
     // gate's screen and its full suite) sums to its own cost and never to the span between them.
@@ -1126,8 +1153,12 @@ export async function runGates(task, ctx) {
                 if (typeof rv.meta.reviewer === "string") {
                     const reviewer = rv.meta.reviewer;
                     const cause = String(rv.meta.cause);
+                    // E1: a checkout-proof timeout is the host being slow to print the seat's proof, not the seat
+                    // failing. It is still a no-verdict re-routed away from for THIS round, but it never strikes the
+                    // run-scoped tally; every other launch failure (foreign or malformed proof included) does.
+                    const proofTimeout = cause === "seat-launch-failed" && rv.meta.launchCause === "checkout-proof-timeout";
                     // OBS-1025 add.2: the run-scoped tally; two no-verdicts retire the seat for the rest of the run.
-                    const causes = rv.meta.noVerdict === true && ctx.reviewNoVerdicts
+                    const causes = rv.meta.noVerdict === true && ctx.reviewNoVerdicts && !proofTimeout
                         ? [...(ctx.reviewNoVerdicts.get(reviewer) ?? []), cause] : undefined;
                     if (causes)
                         ctx.reviewNoVerdicts.set(reviewer, causes);
@@ -1272,51 +1303,9 @@ export async function runGates(task, ctx) {
         if (failed())
             return done();
     }
-    // A non-final round may run only the tests covering its own diff; the merge-candidate round below
-    // pays the full suite anyway, so a selection that misses costs a round and can never merge.
-    let selected = ctx.selectTests && enabled("test") && ctx.commands.test
-        ? await coveringTests(ctx.worktree, ctx.baseRef)
-        : undefined;
-    let selectionReason = ctx.selectionReason ?? (selected ? "affected-tests" : "full-suite-fallback");
-    if (selected && ctx.requiredRepairTests?.length) {
-        const required = ctx.requiredRepairTests;
-        const safe = required.every((path) => posix.normalize(path) === path && !path.startsWith("../")
-            && !path.startsWith("/") && TEST_FILE_RE.test(path) && existsSync(join(ctx.worktree, path)));
-        const listed = safe ? await shGit(`git ls-files -z -- ${required.map(shq).join(" ")}`, ctx.worktree) : undefined;
-        const tracked = new Set(listed?.stdout.split("\0").filter(Boolean));
-        if (!listed || listed.code !== 0 || required.some((path) => !tracked.has(path))) {
-            selected = undefined;
-            selectionReason = "required-repair-test-unavailable";
-        }
-        else
-            selected = [...new Set([...selected, ...required])].sort();
-    }
-    // OBS-635: a screen buys nothing when the full suite that must follow it already has a qualified
-    // green on this exact identity (read BEFORE any screen), or when the harness-measured screen costs
-    // at least 75 % of it — then the full suite runs in the battery instead. Unknown timing keeps the
-    // screen. A selected-only green never answers here: its identity names its selection.
-    let promotion;
-    if (selected) {
-        const hit = verdictStore.get(await fullTestIdentity());
-        const costRatio = screenCostRatio(ctx.baseline, selected);
-        if (hit?.pass === true && !isInfraResult(hit) && await certifiesFullManifest(hit))
-            promotion = { reason: "full-green-cache" };
-        else if (costRatio !== undefined && costRatio >= SCREEN_PROMOTION_RATIO)
-            promotion = { reason: "screen-cost-promoted", costRatio };
-        if (promotion)
-            selected = undefined;
-    }
-    if (ctx.selectionReason || promotion)
-        selectionDecision = {
-            scope: selected ? "selected" : "full", reason: promotion?.reason ?? (selected ? selectionReason
-                : selectionReason === "known-failing-files" ? "unsupported-selection-full-suite" : selectionReason),
-            requiredFiles: [...(ctx.requiredRepairTests ?? [])],
-            ...(promotion?.costRatio !== undefined ? { costRatio: promotion.costRatio } : {}),
-        };
-    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected, enabled("test") ? ["test"] : []);
-    if (failed())
-        return done();
-    if (enabled("acceptance") || enabled("review")) {
+    // The judge and the reviewer, together. Returns true when the round ends here: a red, or a
+    // cancelled sibling — a cancelled seat's round never goes on to borrow a test row.
+    const runSemantics = async () => {
         // Judge and review are launched TOGETHER (96m of serialization over 5 runs). Enforcement is
         // unchanged — it is still the AND of both, both still fail closed, and neither reads the other's
         // verdict: each gets the same commit and the same brief it always got, and neither promise is
@@ -1365,16 +1354,83 @@ export async function runGates(task, ctx) {
         if (failure)
             throw failure.reason;
         executionSignal()?.throwIfAborted();
-        if (failed())
+        return cancelled || failed();
+    };
+    if (semanticFirst) {
+        if (await runSemantics()) {
+            // A cancelled round starts no test, yet its no-verdict review can still be re-asked alone. Its test
+            // proof is recorded OWED — unsatisfied, never a verdict — so that re-ask cannot merge an unrun subject.
+            if (!failed() && enabled("test") && ctx.commands.test !== undefined) {
+                await record({ gate: "test", pass: false, details: "test not run — the semantic round was cancelled before its "
+                        + "test screen; the merge-candidate full suite is still owed on this subject",
+                    meta: { skipped: true, infra: true, classification: "infra", retryable: false, testOwed: true } });
+            }
+            return done();
+        }
+        // Subject freshness: the semantic gates ran oracles and vendor CLIs in this worktree. Their dirt is
+        // not the committed subject, so no screen measures it and no cached green row answers for it.
+        const dirt = enabled("test") && ctx.commands.test !== undefined ? await dirtyWorktree() : undefined;
+        if (dirt) {
+            await emitStart("test");
+            await record(await dirtyRefusal("test", dirt));
             return done();
+        }
+    }
+    // A non-final round may run only the tests covering its own diff; the merge-candidate round below
+    // pays the full suite anyway, so a selection that misses costs a round and can never merge.
+    let selected = ctx.selectTests && enabled("test") && ctx.commands.test
+        ? await coveringTests(ctx.worktree, ctx.baseRef)
+        : undefined;
+    let selectionReason = ctx.selectionReason ?? (selected ? "affected-tests" : "full-suite-fallback");
+    if (selected && ctx.requiredRepairTests?.length) {
+        const required = ctx.requiredRepairTests;
+        const safe = required.every((path) => posix.normalize(path) === path && !path.startsWith("../")
+            && !path.startsWith("/") && TEST_FILE_RE.test(path) && existsSync(join(ctx.worktree, path)));
+        const listed = safe ? await shGit(`git ls-files -z -- ${required.map(shq).join(" ")}`, ctx.worktree) : undefined;
+        const tracked = new Set(listed?.stdout.split("\0").filter(Boolean));
+        if (!listed || listed.code !== 0 || required.some((path) => !tracked.has(path))) {
+            selected = undefined;
+            selectionReason = "required-repair-test-unavailable";
+        }
+        else
+            selected = [...new Set([...selected, ...required])].sort();
+    }
+    // OBS-635: a screen buys nothing when the full suite that must follow it already has a qualified
+    // green on this exact identity (read BEFORE any screen), or when the harness-measured screen costs
+    // at least 75 % of it — then the full suite runs in the battery instead. Unknown timing keeps the
+    // screen. A selected-only green never answers here: its identity names its selection.
+    let promotion;
+    if (selected) {
+        const hit = verdictStore.get(await fullTestIdentity());
+        const costRatio = screenCostRatio(ctx.baseline, selected);
+        if (hit?.pass === true && !isInfraResult(hit) && await certifiesFullManifest(hit))
+            promotion = { reason: "full-green-cache" };
+        else if (costRatio !== undefined && costRatio >= SCREEN_PROMOTION_RATIO)
+            promotion = { reason: "screen-cost-promoted", costRatio };
+        if (promotion)
+            selected = undefined;
     }
+    if (ctx.selectionReason || promotion)
+        selectionDecision = {
+            scope: selected ? "selected" : "full", reason: promotion?.reason ?? (selected ? selectionReason
+                : selectionReason === "known-failing-files" ? "unsupported-selection-full-suite" : selectionReason),
+            requiredFiles: [...(ctx.requiredRepairTests ?? [])],
+            ...(promotion?.costRatio !== undefined ? { costRatio: promotion.costRatio } : {}),
+        };
+    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected, enabled("test") ? ["test"] : []);
+    if (failed())
+        return done();
+    if (semantic && !semanticFirst && await runSemantics())
+        return done();
     // OBS-635: the semantic gates ran oracles and vendor CLIs in this worktree after an in-battery full
     // suite spoke, and its green stands only for the identity it measured. Oracle dirt withdraws it; a
     // changed or unmeasurable identity — tree, command, baseline, environment, dependency resolution,
     // capacity, protocol, lifecycle, full manifest — buys a fresh merge-candidate suite below.
+    // Semantic-first too: an in-battery full suite that ran AFTER the semantic gates is clear of their
+    // dirt, never of its own test command's effects (an ignored lockfile, a newly collected test).
     let rerunFull = false;
     listing = undefined;
-    if (fullInBattery && ctx.commands.test !== undefined && (enabled("acceptance") || enabled("review"))) {
+    if (fullInBattery && ctx.commands.test !== undefined && semantic) {
         const dirt = await dirtyWorktree();
         if (dirt) {
             const refusal = withTelemetry(await dirtyRoundRefusal("test", dirt));

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

@@ -208,4 +208,7 @@ export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
     /** OBS-1166: the configured command BEFORE a selected screen narrowed it, so a stranded retry's
      * only positional filters are the stranded files. Absent (a full suite), `cmd` is that command. */
     retryBaseCommand?: string;
+    /** v2.6.6 C: false on the manifest gate's one outer re-measurement — the second sample is one
+     * execution and never stacks the stranded single-fork recovery on top of the retry it already is. */
+    allowStrandedRecovery?: boolean;
 }): Promise<ManifestGateOutcome>;

package/dist/gates/test-manifest.js

@@ -594,7 +594,7 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
             hangActiveMs: invoked.hangActiveMs, hangWallMs: invoked.hangWallMs });
         evidenceReceipts.push(...invoked.evidenceReceipts);
         const interruptions = [...invoked.interruptions];
-        const stranded = strandedSingleForkFiles(files, nonce, invoked);
+        const stranded = opts.allowStrandedRecovery === false ? undefined : strandedSingleForkFiles(files, nonce, invoked);
         if (stranded) {
             const first = invoked.report;
             const retryNonce = randomBytes(16).toString("hex");

package/dist/gates/timeout-shaped.d.ts

@@ -0,0 +1,3 @@
+export declare const TIMEOUT_SHAPED_RE: RegExp;
+export declare const RUNNER_INFRA_DIAGNOSTIC_RE: RegExp;
+export declare const timeoutShaped: (details: string) => boolean;

package/dist/gates/timeout-shaped.js

@@ -0,0 +1,10 @@
+import { readableExcerpt } from "../run/journal.js";
+// OBS-1106 residual: a red whose assertion is a timeout or a wall-clock budget, and the runner-level
+// diagnostics (never-started files, a worker RPC timeout) that make such a red infrastructure-SHAPED.
+// Shape alone never parks anything: it only buys one isolated re-observation before a charge. A
+// fresh-fingerprint section masks digits to `#`, so both spellings of a number are read.
+// v2.6.6 C: the daemon's declarations (src/run/daemon.ts at 75dc3187:492-494), exported verbatim so the
+// manifest gate's one remeasurement and the daemon's isolated adjudication read ONE predicate.
+export const TIMEOUT_SHAPED_RE = /\b(?:Test|Hook) timed out in (?:\d+|#)\s*ms\b|\bexpected (?:\d+|#)(?:\.(?:\d+|#))? to be (?:less than|below)(?: or equal to)? (?:\d+|#)/i;
+export const RUNNER_INFRA_DIAGNOSTIC_RE = /\bnever-started (?:[1-9]\d*|#)(?![\d#])|\[vitest-worker\]: Timeout calling\b/;
+export const timeoutShaped = (details) => TIMEOUT_SHAPED_RE.test(readableExcerpt(details));