tickmarkr 2.7.1 → 2.7.2

package/dist/gates/baseline.js

@@ -7,7 +7,7 @@ import { basename, join } from "node:path";
 import { DEFAULT_EVIDENCE_QUOTA_BYTES } from "../config/config.js";
 import { dependencyLinkRefusal, 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";
+import { isVitestTestCommand, manifestChildEnv, manifestFileCount } from "./test-manifest.js";
 export const EVIDENCE_TAIL_BYTES = 16 * 1024;
 /** The default per-run quota; `gates.evidenceQuotaBytes` in config overrides it (OBS-1140). */
 export const EVIDENCE_RUN_QUOTA_BYTES = DEFAULT_EVIDENCE_QUOTA_BYTES;
@@ -726,7 +726,11 @@ export async function captureBaseline(cwd, commands, opts = {}) {
             continue;
         }
         const evidence = beginGateEvidence(cwd, name, cmd, opts.evidence);
-        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS, { env: opts.evidence?.env, onReceipt: receipt => { evidence.observe(receipt); opts.onReceipt?.(receipt); } });
+        // Queue row 104 (D-1644): a manifested test command is captured under the test gate's own runner environment
+        // (node_modules/.bin first), so a bare repo-local runner resolves here exactly as it does in the gate — built on the
+        // caller's own evidence environment when it supplies one (D-1659), never in place of it.
+        const env = (name === "test" || name === "tipTest") && isVitestTestCommand(cmd, cwd) ? manifestChildEnv(cwd, opts.evidence?.env) : opts.evidence?.env;
+        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS, { env, onReceipt: receipt => { evidence.observe(receipt); opts.onReceipt?.(receipt); } });
         (base.evidenceReceipts ??= {})[name] = evidence.finish(r.stdout, r.stderr);
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
         // ponytail: a capture that was itself killed records the ceiling as its "measurement", which

package/dist/gates/run-gates.js

@@ -15,11 +15,11 @@ import { disallowedBy, observedSeat } from "../route/preference.js";
 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 { discoverTestManifest, evaluateManifestedTest, isVitestTestCommand, manifestChildEnv } 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, readCapacity, ROUTING_ENV_SEAMS, shGit, resolvedCapacity, sameCapacity, SUITE_PARENT_ENV, verificationProtocol } from "../run/git.js";
+import { dependencyLinkRefusal, preserveWorktree, producerFields, readCapacity, shGit, resolvedCapacity, sameCapacity, verificationProtocol } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
 import { computeVerificationIdentity, verificationIdentityKey, formatReusedRow, getVerdictStore, isInfraResult, resolveStateDir, reusedIdentity, } from "./cache.js";
 const productionLoadProvider = () => loadavg()[0] ?? 0;
@@ -285,11 +285,7 @@ export function diagnosticAdmission(baseline, selected) {
  * discovery receives (test-manifest.ts manifestEnvironment), so it compares with the one a verdict
  * certified. Undefined when the runner cannot list — an unlisted manifest certifies nothing. */
 async function listFullManifest(cmd, worktree) {
-    const env = { ...process.env, PATH: `${join(worktree, "node_modules/.bin")}:${process.env.PATH ?? ""}`,
-        [VITEST_CACHE_ENV]: worktreeVitestCache(worktree),
-        [FORK_CAP_ENV]: String(resolvedCapacity().forkCap), [SUITE_PARENT_ENV]: String(process.pid) };
-    for (const key of [...ROUTING_ENV_SEAMS, "VITEST", "TEST", "VITEST_WORKER_ID", "VITEST_POOL_ID"])
-        delete env[key];
+    const env = manifestChildEnv(worktree);
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-full-manifest-"));
     try {
         return (await discoverTestManifest(cmd, worktree, { dir, nonce: randomUUID(), env })).files;

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

@@ -206,6 +206,9 @@ export interface ManifestGateOutcome {
     exitCode: number;
     reportPath: string;
 }
+/** Queue row 104 (D-1644): THE child environment of a manifested test command — its listing and run here, the full
+ * manifest re-listing (run-gates.ts) and its baseline capture (baseline.ts) — so every one resolves the same runner. */
+export declare function manifestChildEnv(cwd: string, base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export interface DiscoveredManifest {
     files: string[];
     listing: string;

package/dist/gates/test-manifest.js

@@ -504,17 +504,22 @@ export function runManifestedTest(cmd, cwd, opts) {
  * `npm_config_ignore_scripts` from the environment over every npmrc); the verdict records it so a
  * verdict measured with `pretest` hooks is never compared to one without. */
 function manifestEnvironment(cwd) {
-    const env = { ...process.env, PATH: `${join(cwd, "node_modules/.bin")}:${process.env.PATH ?? ""}`,
+    const env = manifestBaseEnv(cwd);
+    return { env: scrubbedManifestEnv(env), verification: verificationProtocol(env, cwd) };
+}
+function manifestBaseEnv(cwd, base = process.env) {
+    return { ...base, PATH: `${join(cwd, "node_modules/.bin")}:${base.PATH ?? ""}`,
         [VITEST_CACHE_ENV]: worktreeVitestCache(cwd),
         [FORK_CAP_ENV]: String(resolvedCapacity().forkCap), [SUITE_PARENT_ENV]: String(process.pid) };
-    const verification = verificationProtocol(env, cwd);
-    for (const key of ROUTING_ENV_SEAMS)
-        delete env[key];
-    // A gate can itself be tested under Vitest. Do not give the child the outer worker identity.
-    for (const key of Object.keys(env))
-        if (["VITEST", "TEST", "VITEST_WORKER_ID", "VITEST_POOL_ID"].includes(key))
-            delete env[key];
-    return { env, verification };
+}
+// A gate can itself be tested under Vitest. Do not give the child the outer worker identity.
+const OUTER_RUNNER_KEYS = new Set([...ROUTING_ENV_SEAMS, "VITEST", "TEST", "VITEST_WORKER_ID", "VITEST_POOL_ID"]);
+const scrubbedManifestEnv = (env) => Object.fromEntries(Object.entries(env).filter(([key]) => !OUTER_RUNNER_KEYS.has(key)));
+/** Queue row 104 (D-1644): THE child environment of a manifested test command — its listing and run here, the full
+ * manifest re-listing (run-gates.ts) and its baseline capture (baseline.ts) — so every one resolves the same runner. */
+export function manifestChildEnv(cwd, base) {
+    // built on `base` when a caller supplies its own environment (captureBaseline's evidence env), else on process.env
+    return scrubbedManifestEnv(manifestBaseEnv(cwd, base));
 }
 /** OBS-1044: THE discovery seam — the files the runner would collect under this exact invocation,
  * from its own listing and never from a stdout summary. The gate and the baseline capture share it,

package/dist/run/daemon.d.ts

@@ -4,7 +4,7 @@ import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 import { type Baseline, type BaselineProvenance, type GateEvidenceOptions } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
-import { type RunGraph } from "../graph/schema.js";
+import { type RunGraph, type Task } from "../graph/schema.js";
 import { type PreserveProducer } from "./git.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export declare function closeLiveSlot(liveSlots: Set<Slot>, driver: Pick<ExecutorDriver, "close">, slot: Slot): Promise<void>;
@@ -144,6 +144,19 @@ export declare const gateSatisfied: (g: GateResult) => boolean;
  * preference (ranked last, never excluded) — every review-pool-demotion except the launch-caused ones, which
  * never demote a seat (live or replayed). plan.ts previews a resume with this same fold. */
 export declare function replayedReviewerDemotions(events: readonly JournalEvent[]): Set<string>;
+/** C: a journaled test red whose failing-file attribution is nonempty, trustworthy and complete (repair
+ * selection's own rule: a behavioral red on a real subject from a full suite or a screen that names
+ * every failure), POSITIVELY certified complete by its runner, uncontradicted by the files its own text
+ * names, and wholly outside a declared files[]. Empty files[] is unrestricted and never qualifies;
+ * every other shape keeps its replay. */
+export declare function outsideScopeRed(t: Task, taskId: string, data: Record<string, unknown>, commit: string): boolean;
+/** OBS-1106 residual, D-607: what ONE isolated rerun of a timeout-shaped red's attributed `files` says about that
+ * red. Lifted unchanged out of adjudicateInfraShapedRed (queue row 102) so its closed outcome table runs on this
+ * function in-process. Pure: it reads only its arguments; the caller classifies the rerun first. */
+export declare function reobservationOutcome(files: readonly string[], rerun: GateResult): {
+    outcome: "reproduced" | "passed" | "ambiguous";
+    selection: string[] | undefined;
+};
 /**
  * T4 (OBS-265): the journal with the review objections a round did NOT hinge on removed. Judge and
  * review are now launched together, so a round can journal a failed review that the serial walk would

package/dist/run/daemon.js

@@ -409,7 +409,7 @@ const RUNNER_CERTIFICATE_RE = /runner-level diagnostic: never-started ([^;\s]+);
  * every failure), POSITIVELY certified complete by its runner, uncontradicted by the files its own text
  * names, and wholly outside a declared files[]. Empty files[] is unrestricted and never qualifies;
  * every other shape keeps its replay. */
-function outsideScopeRed(t, taskId, data, commit) {
+export function outsideScopeRed(t, taskId, data, commit) {
     if (!t.files.length || data.gate !== "test" || data.pass !== false || data.skipped === true || data.commit !== commit
         // a failed producer — an infra row, a dirty-tree refusal, a recovery the runner could not finish —
         // never attributes anything, whatever files it lists
@@ -456,6 +456,21 @@ const observedSelection = (g) => {
 /** D-607: on the manifest path only the reporter's own attribution counts — a `FAIL path` line inside
  * captured stdout is text, not attribution. Headline lexing is for runners without a reporter. */
 const rerunFailingFiles = (g) => metaFiles(g.meta?.manifest) ? [...new Set(metaFiles(g.meta?.failingFiles) ?? [])].sort() : attributedFailingFiles(g);
+/** OBS-1106 residual, D-607: what ONE isolated rerun of a timeout-shaped red's attributed `files` says about that
+ * red. Lifted unchanged out of adjudicateInfraShapedRed (queue row 102) so its closed outcome table runs on this
+ * function in-process. Pure: it reads only its arguments; the caller classifies the rerun first. */
+export function reobservationOutcome(files, rerun) {
+    // Reproduced only by failure evidence the rerun ATTRIBUTES to one of exactly these files, from an
+    // OBSERVED selection that was exactly these files (D-607): a path merely printed in output, a
+    // positional filter that also collected another file, or a runner that ignored the file
+    // arguments and reported no manifest of its selection, says nothing about the original red.
+    const failing = rerunFailingFiles(rerun);
+    const selection = observedSelection(rerun);
+    const isolated = selection !== undefined && selection.length === files.length
+        && files.every((file) => selection.includes(file)) && failing.every((file) => files.includes(file));
+    const outcome = rerun.pass ? "passed" : isolated && !isInfraResult(rerun) && failing.length ? "reproduced" : "ambiguous";
+    return { outcome, selection };
+}
 // v1.85 T3: the gates whose failure IS a deterministic measurement — a machine re-ran a command over a
 // tree and printed the same bytes. Those are the failures the fingerprint cap governs (the ruling names
 // it a "deterministic-gate" cap): a third identical answer to a question already answered twice is the
@@ -3080,15 +3095,9 @@ export async function runDaemon(repoRoot, opts = {}) {
                             rerun = await withCommandContext(t.id, () => reobserveTestFiles(wt, commands.test, baseline, files, journal.dir))
                                 .catch((error) => ({ gate: "test", pass: false, details: `infra: rerun failed: ${error instanceof Error ? error.message : String(error)}`, meta: { infra: true } }));
                             classifyInfraResult(rerun);
-                            // Reproduced only by failure evidence the rerun ATTRIBUTES to one of exactly these files, from an
-                            // OBSERVED selection that was exactly these files (D-607): a path merely printed in output, a
-                            // positional filter that also collected another file, or a runner that ignored the file
-                            // arguments and reported no manifest of its selection, says nothing about the original red.
-                            const failing = rerunFailingFiles(rerun);
-                            selection = observedSelection(rerun);
-                            const isolated = selection !== undefined && selection.length === files.length
-                                && files.every((file) => selection.includes(file)) && failing.every((file) => files.includes(file));
-                            outcome = rerun.pass ? "passed" : isolated && !isInfraResult(rerun) && failing.length ? "reproduced" : "ambiguous";
+                            const judged = reobservationOutcome(files, rerun);
+                            outcome = judged.outcome;
+                            selection = judged.selection;
                         }
                         journal.append("gate-reobserved", t.id, {
                             gate: "test", attempt, commit: subject, fingerprint, ...(observation ? { observation } : {}), files, outcome,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",