tickmarkr 2.1.7 → 2.1.8

package/dist/cli/commands/doctor.d.ts

@@ -3,6 +3,7 @@ import type { WorkerAdapter } from "../../adapters/types.js";
 import { type KimiDoctorTurnResult } from "../../adapters/kimi.js";
 import { type CatalogReadResult } from "../../adapters/catalog-remote.js";
 import { type ShResult } from "../../run/git.js";
+import { type VitestListResult } from "../../gates/acceptance.js";
 /** Where a newer `table_<date>.csv` is discovered — the deployed site builds filenames by
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export declare const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
@@ -20,6 +21,8 @@ export type DoctorOpts = {
     orcaStatusProbe?: (cwd: string, binary: string) => Promise<ShResult>;
     /** Test seam for shell-path discovery; absence remains a normal doctor row, never an exception. */
     resolveOrcaBinary?: (cwd: string) => string | undefined;
+    /** Test seam for the runner-owned JSON listing used by the acceptance-oracle report row. */
+    listTests?: (cwd: string) => Promise<VitestListResult>;
 };
 type OrcaCapability = {
     verdict: "pass" | "fail";

package/dist/cli/commands/doctor.js

@@ -8,7 +8,7 @@ import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnin
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { shq } from "../../adapters/types.js";
 import { BANNER, compactTokens, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
-import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
+import { graphPath, loadGraph, tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
@@ -17,6 +17,7 @@ import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 import { LIVEBENCH_TABLE_DATE, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
 import { sh } from "../../run/git.js";
+import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 /** Where a newer `table_<date>.csv` is discovered — the deployed site builds filenames by
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
@@ -362,6 +363,27 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const healthy = h.installed && (a.id !== kimi.id || h.authed);
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
+    if (existsSync(graphPath(cwd))) {
+        try {
+            const graph = loadGraph(cwd);
+            const items = graph.tasks.flatMap((task) => task.acceptance);
+            if (items.some((item) => typeof item === "object" && item.oracle === "test")) {
+                const listing = await (opts.listTests ?? listVitestTests)(cwd);
+                if (listing.status === "failed") {
+                    rows.push(alignedStatusRow("fail", "acceptance-oracles", `runner listing failed — ${listing.error.split("\n")[0]}`));
+                }
+                else {
+                    const audited = auditNamedTestOracles(items, listing.tests);
+                    const resolved = audited.filter((row) => row.matches.length === 1).length;
+                    const verdict = resolved === audited.length ? "pass" : "fail";
+                    rows.push(alignedStatusRow(verdict, "acceptance-oracles", `${resolved}/${audited.length} resolved — each resolved oracle's shipped filter matches exactly one runner-listed test`));
+                }
+            }
+        }
+        catch (error) {
+            rows.push(alignedStatusRow("fail", "acceptance-oracles", `graph unreadable — ${error instanceof Error ? error.message : String(error)}`));
+        }
+    }
     if (catalog.warning) {
         rows.push(attentionRow(`model catalog cache unreadable — ${catalog.warning}; using vendored fallback (advisory — routing unchanged)`));
     }

package/dist/cli/commands/plan.d.ts

@@ -1,2 +1,6 @@
-import type { WorkerAdapter } from "../../adapters/types.js";
-export declare function plan(argv: string[], cwd?: string, adapters?: WorkerAdapter[], harnessFrom?: string | undefined): Promise<string>;
+import { type VitestListResult } from "../../gates/acceptance.js";
+import { type WorkerAdapter } from "../../adapters/types.js";
+export type PlanOpts = {
+    listTests?: (cwd: string) => Promise<VitestListResult>;
+};
+export declare function plan(argv: string[], cwd?: string, adapters?: WorkerAdapter[], harnessFrom?: string | undefined, opts?: PlanOpts): Promise<string>;

package/dist/cli/commands/plan.js

@@ -3,15 +3,20 @@ import { formatModelAuthLine, contextWindowLints, modelLints, preferEntryLints,
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { parseArgs } from "node:util";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
+import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
 import { loadGraph } from "../../graph/graph.js";
+import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { excludedChannels, exclusionLine } from "../../route/preference.js";
 import { staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
+import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId } from "../../gates/review.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
+import { shq } from "../../adapters/types.js";
+import { shGit } from "../../run/git.js";
 // T4 (v1.50): TTY-only brand pass — the title helper frames the routing table, lint/unroutable
 // markers carry the attention glyph, section labels dim to chrome (the doctor/status system).
 // Gated on ttyVisual(): the non-TTY surface returns untouched (byte-pinned, machine-consumable).
@@ -35,12 +40,60 @@ const fleetCanCrossVendorReview = (channels) => {
                 return true;
     return false;
 };
+const NAMED_CRITERION_PATH = /(?:^|[\s("'`])((?:src|tests|fixtures|scripts)\/[A-Za-z0-9_@{}*?.,/+-]+\.(?:tsx|ts|jsx|json|js|mjs|cjs|md|txt))(?![A-Za-z0-9])/g;
+async function taskInputFindings(tasks, cwd) {
+    const pathsByTask = tasks.map((task) => {
+        const paths = new Set(task.files.map((path) => path.replace(/^\.\//, "")));
+        for (const item of task.acceptance) {
+            const texts = typeof item === "string"
+                ? [item]
+                : [renderAcceptanceItem(item), ...Object.values(item).filter((value) => typeof value === "string")];
+            for (const text of texts) {
+                for (const match of text.matchAll(NAMED_CRITERION_PATH))
+                    paths.add(match[1]);
+            }
+        }
+        return { task, paths: [...paths] };
+    });
+    if (pathsByTask.every(({ paths }) => paths.length === 0))
+        return [];
+    const [tree, diff] = await Promise.all([
+        shGit("git ls-tree --full-tree -r --name-only -z HEAD", cwd),
+        shGit("git diff --name-only -z HEAD --", cwd),
+    ]);
+    if (tree.code !== 0 || diff.code !== 0)
+        return [];
+    const tracked = new Set(tree.stdout.split("\0").filter(Boolean));
+    const changed = new Set(diff.stdout.split("\0").filter(Boolean));
+    const findings = [];
+    for (const { task, paths } of pathsByTask) {
+        for (const path of paths) {
+            const state = classifyContextPath(path, tracked, cwd);
+            if (state.kind === "untracked") {
+                findings.push({
+                    taskId: task.id,
+                    severity: "refuse",
+                    detail: `task path ${JSON.stringify(path)} exists in the working tree but no commit holds it`,
+                });
+            }
+            else if (state.kind === "ok"
+                && (changed.has(path) || [...changed].some((candidate) => candidate.startsWith(`${path}/`)))) {
+                findings.push({
+                    taskId: task.id,
+                    severity: "warn",
+                    detail: `tracked path ${JSON.stringify(path)} differs from HEAD — run git restore -- ${shq(path)} to discard the divergence, or commit it before dispatch`,
+                });
+            }
+        }
+    }
+    return findings;
+}
 // v1.89 T4: harnessFrom is the resolver's INPUT — a caller (the byte-pinned goldens) fixes the location
 // and keeps this machine's absolute paths out of a fixture. The default is the INVOKED entrypoint,
 // `process.argv[1]`: the bin symlink a global install puts on PATH, which resolves to dist/cli/index.js.
 // It is NOT `import.meta.url` — that names dist/cli/commands/plan.js, an internal module of the harness
 // rather than the harness that was invoked, so the banner would identify the wrong file entirely.
-export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(), harnessFrom = process.argv[1]) {
+export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(), harnessFrom = process.argv[1], opts = {}) {
     // ponytail: hardcoded 24h TTL — promote to config when an operator asks. mtime is the signal because
     // doctor.json has no probe timestamp and a schema field would break the existing-files compat invariant.
     const DOCTOR_STALE_MS = 24 * 60 * 60 * 1000;
@@ -51,6 +104,37 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
     const g = loadGraph(cwd);
+    const oracleRefusals = new Map();
+    if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
+        const listing = await (opts.listTests ?? listVitestTests)(cwd);
+        for (const task of g.tasks) {
+            const refusals = [];
+            if (listing.status === "failed") {
+                if (task.acceptance.some((item) => typeof item === "object" && item.oracle === "test")) {
+                    refusals.push(`acceptance oracle unresolved — runner listing failed: ${listing.error.split("\n")[0]}`);
+                }
+            }
+            else {
+                for (const audit of auditNamedTestOracles(task.acceptance, listing.tests)) {
+                    if (audit.matches.length === 0) {
+                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches zero runner-listed test names`);
+                    }
+                    else if (audit.matches.length > 1) {
+                        refusals.push(`acceptance oracle ${JSON.stringify(audit.criterion)} matches ${audit.matches.length} runner-listed test names`);
+                    }
+                }
+            }
+            if (refusals.length)
+                oracleRefusals.set(task.id, refusals);
+        }
+    }
+    const inputFindings = await taskInputFindings(g.tasks, cwd);
+    const inputRefusals = new Map();
+    for (const finding of inputFindings) {
+        if (finding.severity !== "refuse")
+            continue;
+        inputRefusals.set(finding.taskId, [...(inputRefusals.get(finding.taskId) ?? []), finding.detail]);
+    }
     const { cfg, mode, source } = resolveRunMode(cwd, { flag: values.mode, spec: g.mode });
     // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).
     const cached = readDoctor(cwd);
@@ -152,6 +236,11 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     let cost = 0;
     const routed = [];
     for (const t of g.tasks) {
+        const refusals = [...(oracleRefusals.get(t.id) ?? []), ...(inputRefusals.get(t.id) ?? [])];
+        if (refusals.length) {
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! pre-dispatch refusal — ${refusals.join("; ")}`);
+            continue;
+        }
         try {
             const r = route(t, cfg, channels, dispatchProfile);
             routed.push({ taskId: t.id, adapter: r.assignment.adapter, model: r.assignment.model });
@@ -192,6 +281,10 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             lints.push(`${t.id}: unroutable — ${msg}`);
         }
     }
+    const inputWarnings = inputFindings.filter((finding) => finding.severity === "warn");
+    if (inputWarnings.length) {
+        lines.push("", "input warnings:", ...inputWarnings.map((finding) => `  ! ${finding.taskId}: ${finding.detail}`));
+    }
     lines.push("", `est. cost (API channels only, rough): ~$${cost.toFixed(2)} + judge/review/consult calls`);
     // VIS-04: summary only when a profile is active AND something deviates. Labeled by the switch — off = preview.
     if (profile && deviations) {

package/dist/cli/commands/status.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { DEFAULT_CONFIG, loadConfig } from "../../config/config.js";
@@ -7,8 +7,8 @@ import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
-import { Journal, engagementComparable, isQualityFailureParkKind, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
-import { isPidLive } from "../../run/lock.js";
+import { Journal, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
+import { isPidLive, runLockOwner } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
 import { normalizeStallSnapshot } from "../../run/stall.js";
@@ -850,20 +850,56 @@ const parseJournalSnapshot = (raw) => raw.split("\n").flatMap((line) => {
         return [];
     }
 });
+// runLockOwner is the single lock payload/liveness reader. Its current path helper also initializes
+// .tickmarkr metadata; an engine-written lock necessarily passed through that initializer already, so
+// status avoids invoking it in stripped reader-purity fixtures where no engine lock can exist.
+const canReadRunLockOwner = (cwd) => existsSync(join(cwd, stateDirName(cwd), ".gitignore"));
+const reportableLockRunId = (owner) => {
+    if (!owner?.live || owner.runId === undefined)
+        return undefined;
+    try {
+        return parseRunId(owner.runId);
+    }
+    catch {
+        // Repository-wide locks can be held for non-run work such as compile; those are not a status run.
+        return undefined;
+    }
+};
+const readRunJournalRaw = (cwd, runId, allowMissingJournal) => {
+    const dir = join(cwd, stateDirName(cwd), "runs", runId);
+    try {
+        return readFileSync(join(dir, "journal.jsonl"), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            if (allowMissingJournal)
+                return "";
+            throw new Error(`no journal for ${runId} at ${dir}`);
+        }
+        throw error;
+    }
+};
 /**
  * ONE journal read per answer, and every claim about the run folded from THOSE bytes — the board's
  * task rows, activity, phases, gates, liveness and tip verification, and the compact one-line form
  * alike. A second read is what lets two snapshots be presented as one state: a line the daemon
  * appends between them pairs a task count from one instant with a verdict from another.
  *
- * An explicit <runId> is a resolution, not a hint: `Journal.open` refuses an id without a readable
- * journal, so status fails loudly naming that id instead of rendering any other run.
+ * An explicit <runId> is a resolution, not a hint: it refuses an id without a readable journal, so
+ * status fails loudly naming that id instead of rendering any other run. The implicit form first
+ * asks the repository lock accessor which run is live, then falls back to the newest journalled run;
+ * a lock-selected run may still be in the directory-before-first-journal window, which renders as an
+ * empty snapshot for that run rather than borrowing the previous run's journal.
  */
 const readRunRecord = (cwd, graph, namedRunId) => {
-    const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
+    const explicitRunId = namedRunId === undefined ? undefined : parseRunId(namedRunId);
+    const lockedRunId = explicitRunId === undefined && canReadRunLockOwner(cwd)
+        ? reportableLockRunId(runLockOwner(cwd))
+        : undefined;
+    const runId = explicitRunId ?? lockedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
         return undefined;
-    const raw = readFileSync(join(Journal.open(cwd, runId).dir, "journal.jsonl"), "utf8");
+    const raw = readRunJournalRaw(cwd, runId, lockedRunId === runId);
     const events = parseJournalSnapshot(raw);
     // The resume comparator is the fail-closed baseline; a matching graph-rehash is the daemon's
     // append-only audit that authorizes this status replay after stop-amend-resume.
@@ -1380,15 +1416,19 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     let journalCursor = 0;
     const consumeDecisionEvents = () => {
         // A named run is followed, never re-resolved: --watch <runId> keeps reporting that run even as
-        // newer runs start. Only the no-argument form tracks latest, as before.
-        const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
+        // newer runs start. The no-argument form tracks the live lock first, then latest journal.
+        const explicitRunId = namedRunId === undefined ? undefined : parseRunId(namedRunId);
+        const lockedRunId = explicitRunId === undefined && canReadRunLockOwner(cwd)
+            ? reportableLockRunId(runLockOwner(cwd))
+            : undefined;
+        const runId = explicitRunId ?? lockedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
         if (!runId)
             return [];
         if (decisionRunId !== runId) {
             decisionRunId = runId;
             journalCursor = 0;
         }
-        const journalEvents = Journal.open(cwd, runId).read();
+        const journalEvents = parseJournalSnapshot(readRunJournalRaw(cwd, runId, lockedRunId === runId));
         if (journalEvents.length < journalCursor)
             journalCursor = 0;
         const fresh = decisionEventsFromJournal(journalEvents, runId, stateDirName(cwd))

package/dist/compile/index.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { validateGraph } from "../graph/schema.js";
 import { taskUnitContractErrors } from "./collateral.js";
-import { ownershipFindings, renderOwnershipFinding } from "./ownership.js";
+import { blocksCompile, ownershipFindings, renderOwnershipFinding } from "./ownership.js";
 import { CompileError } from "./common.js";
 import { compileGsd, isGsdPhaseDir } from "./gsd.js";
 import { compileNative, TICKMARKR_NATIVE_MARKER } from "./native.js";
@@ -53,13 +53,23 @@ export function finalizePlan(plan, src, repoRoot) {
         },
         tasks: plan.tasks,
     }), src);
-    // overseer-217: report-only in 2.1.7. The 2.1.8 removal condition is one real authored-graph run
-    // plus a measured false-positive rate for the conventional source-name → test-name mapping.
-    // Until then this warning MUST NOT become a compile abort: a heuristic cannot deadlock compile.
+    // overseer-217 removal condition, now paid: on this milestone's authored graph the conventional
+    // name map emitted 21 raw unowned-test findings; review found 1 real and 20 false, while intersecting
+    // with a direct import or command-entry spawn retained the real one and left 0 false positives. That
+    // is a precision measurement, NOT a recall claim. The prior halted semantic-contract class has no
+    // name/import/ownership relation (one of its three members has no matching literal anywhere), so this
+    // rule could not have caught it and does not claim to. The promoted rule already earned a true positive
+    // during authoring: assigning the plan command to oracle-preflight left two dedicated plan tests unowned.
     if (repoRoot) {
-        for (const finding of ownershipFindings(graph.tasks, repoRoot)) {
+        const findings = ownershipFindings(graph.tasks, repoRoot);
+        const blocking = findings.filter(blocksCompile);
+        for (const finding of findings.filter((item) => !blocksCompile(item))) {
             console.warn(renderOwnershipFinding(finding));
         }
+        if (blocking.length > 0) {
+            throw new CompileError(`${src} violates cross-task test ownership (${blocking.length} error${blocking.length === 1 ? "" : "s"}):\n`
+                + blocking.map((finding) => `  - ${renderOwnershipFinding(finding)}`).join("\n"));
+        }
     }
     return graph;
 }

package/dist/compile/native.js

@@ -789,6 +789,20 @@ acceptance is required on every task (a nested list of observable outcomes).
       hard value anywhere in the domain, the criterion asserts a universal that may be FALSE ABOUT THE
       WORLD — bound it or say where it stops holding, rather than demanding a value that does not exist.
 
+  PICK THE CRITERION FORM FROM WHO COULD BE WRONG:
+    - When the WORKER could be wrong because it can choose the value, use "test:" and pin the exact
+      literal it could otherwise choose; an example selected by its implementer proves only itself.
+    - When the AUTHOR could be wrong by omitting a member from a list, quantify universally over the
+      authoritative closed set; a hand-written enumeration can repeat the same omission as the code.
+    - When the REVIEWER could be wrong about a prose artefact, use "judge:" to replay a recorded incident
+      against the changed prose; a keyword check proves vocabulary, not that the artefact prevents a repeat.
+
+  PRE-SCOPE BY TEXT, ENUMERATE BLOCKERS BY EXECUTION:
+    - Before assigning files[], sweep text across the repository tree for names, callers, tests and prose.
+      A text sweep produces a candidate list; only running the change enumerates the real blocker set.
+      Keep the candidates for scope, then execute the production path and full gates before declaring the
+      set closed — this milestone paid a halted run to learn that the two populations are not identical.
+
   WHICH SIDE OF A RUN INHERITS ENVIRONMENT — AND IT DEPENDS ON THE DRIVER (OBS-542):
     - Gate commands and "command:"/"test:" oracles INHERIT THE DAEMON'S ENVIRONMENT. They are children of
       the daemon, so launching it as \`bash -c 'set -a; . .env.test; set +a; exec tickmarkr run'\` reaches

package/dist/compile/ownership.d.ts

@@ -1,8 +1,17 @@
 import type { Task } from "../graph/schema.js";
+export type OwnershipCorroboration = {
+    kind: "direct-import";
+    source: string;
+} | {
+    kind: "command-entry-spawn";
+    source: string;
+    entry: "src/cli/index.ts";
+};
 export type OwnershipFinding = {
     code: "unowned-test";
     test: string;
     taskIds: string[];
+    corroboration?: OwnershipCorroboration;
     detail: string;
 } | {
     code: "test-path-outside-allowlist";
@@ -18,8 +27,9 @@ export type OwnershipFinding = {
     detail: string;
 };
 /**
- * Advisory cross-task ownership check. Findings are data: callers may report them, but this checker
- * never throws and never changes the graph.
+ * Cross-task ownership evidence. Findings are data: this checker never throws or changes the graph;
+ * the compile seam promotes only a corroborated unowned-test finding and reports every other shape.
  */
 export declare function ownershipFindings(tasks: readonly Task[], repoRoot: string): OwnershipFinding[];
 export declare function renderOwnershipFinding(finding: OwnershipFinding): string;
+export declare function blocksCompile(finding: OwnershipFinding): boolean;

package/dist/compile/ownership.js

@@ -1,5 +1,5 @@
 import { readFileSync, readdirSync } from "node:fs";
-import { basename, extname, join } from "node:path";
+import { basename, extname, join, posix } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { collateralHits } from "./collateral.js";
 const normalize = (path) => path.replace(/^\.\//, "").split("\\").join("/");
@@ -22,20 +22,79 @@ function testSources(repoRoot) {
         return [];
     }
 }
-// Conventional, not universal: status-watch-alive.test.ts is dedicated to status.ts even though it
-// reaches that command through the CLI entry point. Keep this heuristic advisory until authored-graph
-// measurements establish its false-positive rate.
-function namedSourceTasks(test, tasks) {
+function namedSources(test, tasks) {
     const stem = basename(test).replace(/\.test\.ts$/, "");
-    const ids = new Set();
+    const matches = new Map();
     for (const task of tasks) {
         for (const entry of task.files.map(normalize).filter((path) => path.startsWith("src/") && !/[*?{[]/.test(path))) {
             const source = basename(entry, extname(entry));
-            if (stem === source || stem.startsWith(`${source}-`))
-                ids.add(task.id);
+            if (stem === source || stem.startsWith(`${source}-`)) {
+                matches.set(`${task.id}:${entry}`, { taskId: task.id, source: entry });
+            }
+        }
+    }
+    return [...matches.values()];
+}
+const moduleKey = (path) => normalize(path).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+function directImportSpecifiers(text) {
+    // Comments cannot create an edge. Keep strings intact because they are the import target.
+    const source = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+    const specifiers = new Set();
+    for (const match of source.matchAll(/\bimport\s+(?:type\s+)?(?:[\w$*{},\s]+?\s+from\s+)?["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    for (const match of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+        specifiers.add(match[1]);
+    }
+    return [...specifiers];
+}
+function directlyImports(test, source) {
+    // DIRECT is load-bearing: do not walk through imported helpers. src/run/journal.ts alone has 84
+    // test importers in the measured tree, so transitive closure would recreate the raw alarm flood.
+    const target = moduleKey(source);
+    return directImportSpecifiers(test.text).some((specifier) => {
+        const imported = specifier.startsWith(".")
+            ? posix.normalize(posix.join(posix.dirname(test.path), specifier))
+            : specifier.startsWith("src/") ? specifier : "";
+        return imported !== "" && moduleKey(imported) === target;
+    });
+}
+function invokesChildProcessSpawn(text) {
+    const source = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+    const bindings = new Set();
+    for (const match of source.matchAll(/\bimport\s*{([^}]*)}\s*from\s*["'](?:node:)?child_process["']/g)) {
+        for (const member of match[1].split(",")) {
+            const binding = member.trim().match(/^spawn(?:Sync)?(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+            if (binding)
+                bindings.add(binding[1] ?? member.trim());
         }
     }
-    return [...ids];
+    for (const match of source.matchAll(/\bimport\s*\*\s*as\s*([A-Za-z_$][\w$]*)\s*from\s*["'](?:node:)?child_process["']/g)) {
+        if (new RegExp(`\\b${match[1]}\\.spawn(?:Sync)?\\s*\\(`).test(source))
+            return true;
+    }
+    return [...bindings].some((binding) => new RegExp(`\\b${binding}\\s*\\(`).test(source));
+}
+function mentionsCommandEntry(text) {
+    return /(?:^|\/)src\/cli\/index\.(?:ts|js)\b/.test(text)
+        || /["'`]src["'`]\s*,\s*["'`]cli["'`]\s*,\s*["'`]index\.(?:ts|js)["'`]/.test(text);
+}
+function corroboration(test, matches) {
+    // A .test.ts-shaped collateral fixture is not by itself a dedicated test. Requiring a runner leaf
+    // keeps import-only scan fixtures advisory while every executable subject in the measured union stays.
+    const executable = test.text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+    if (!/\b(?:test|it)(?:\.(?:concurrent|each|fails|only|skip|todo))*\s*\(/.test(executable))
+        return undefined;
+    for (const match of matches) {
+        if (directlyImports(test, match.source))
+            return { kind: "direct-import", source: match.source };
+    }
+    if (invokesChildProcessSpawn(test.text) && mentionsCommandEntry(test.text)) {
+        const command = matches.find(({ source }) => /^src\/cli\/commands\/[^/]+\.(?:[cm]?[jt]sx?)$/.test(source));
+        if (command)
+            return { kind: "command-entry-spawn", source: command.source, entry: "src/cli/index.ts" };
+    }
+    return undefined;
 }
 function repositoryPaths(text) {
     const paths = new Set();
@@ -62,11 +121,12 @@ function dependencyOrdered(a, b, byId) {
     return reaches(a, b.id) || reaches(b, a.id);
 }
 /**
- * Advisory cross-task ownership check. Findings are data: callers may report them, but this checker
- * never throws and never changes the graph.
+ * Cross-task ownership evidence. Findings are data: this checker never throws or changes the graph;
+ * the compile seam promotes only a corroborated unowned-test finding and reports every other shape.
  */
 export function ownershipFindings(tasks, repoRoot) {
     const sources = testSources(repoRoot);
+    const sourceByPath = new Map(sources.map((source) => [source.path, source]));
     const byId = new Map(tasks.map((task) => [task.id, task]));
     const indexed = tasks.map((task) => {
         const files = task.files.map(normalize);
@@ -81,6 +141,8 @@ export function ownershipFindings(tasks, repoRoot) {
     const predictedBy = new Map();
     for (const [taskId, hits] of collateralHits(tasks, repoRoot)) {
         for (const hit of hits) {
+            if (!sourceByPath.has(hit))
+                continue;
             const ids = predictedBy.get(hit) ?? new Set();
             ids.add(taskId);
             predictedBy.set(hit, ids);
@@ -88,7 +150,7 @@ export function ownershipFindings(tasks, repoRoot) {
     }
     for (const source of sources) {
         const ids = predictedBy.get(source.path) ?? new Set();
-        for (const taskId of namedSourceTasks(source.path, tasks))
+        for (const { taskId } of namedSources(source.path, tasks))
             ids.add(taskId);
         if (ids.size > 0)
             predictedBy.set(source.path, ids);
@@ -97,11 +159,17 @@ export function ownershipFindings(tasks, repoRoot) {
     for (const [test, taskIds] of predictedBy) {
         if (owners(test).length === 0) {
             const ids = [...taskIds].sort();
+            const source = sourceByPath.get(test);
+            const evidence = corroboration(source, namedSources(test, tasks));
             findings.push({
                 code: "unowned-test",
                 test,
                 taskIds: ids,
-                detail: `${test} is a dedicated test of source owned by ${ids.join(", ")} but no task owns the test`,
+                ...(evidence ? { corroboration: evidence } : {}),
+                detail: `${test} is a dedicated test of source owned by ${ids.join(", ")} but no task owns the test`
+                    + (evidence?.kind === "direct-import" ? `; it imports ${evidence.source} directly`
+                        : evidence?.kind === "command-entry-spawn"
+                            ? `; it spawns ${evidence.entry} to exercise ${evidence.source}` : ""),
             });
         }
     }
@@ -140,3 +208,6 @@ export function ownershipFindings(tasks, repoRoot) {
 export function renderOwnershipFinding(finding) {
     return `tickmarkr: ownership-lint[${finding.code}]: ${finding.detail}`;
 }
+export function blocksCompile(finding) {
+    return finding.code === "unowned-test" && finding.corroboration !== undefined;
+}

package/dist/gates/acceptance.d.ts

@@ -28,6 +28,19 @@ export interface VitestListedTest {
     file: string;
     projectName?: string;
 }
+export type VitestListResult = {
+    status: "listed";
+    tests: VitestListedTest[];
+} | {
+    status: "failed";
+    error: string;
+};
+export declare function listVitestTests(cwd: string): Promise<VitestListResult>;
+export interface NamedTestAudit {
+    criterion: string;
+    matches: VitestListedTest[];
+}
+export declare function auditNamedTestOracles(items: readonly AcceptanceItem[], listedTests: readonly VitestListedTest[]): NamedTestAudit[];
 export type AcceptanceCorpusAuditResult = {
     specPath: string;
     status: "parse-failed";

package/dist/gates/acceptance.js

@@ -98,6 +98,47 @@ export function testFiltered(testCmd, name) {
     const fwd = wrapped ? "-- " : "";
     return `${testCmd} ${fwd}-t ${shq(pattern)}`;
 }
+const VitestListedTestsSchema = z.array(z.object({
+    name: z.string(),
+    file: z.string(),
+    projectName: z.string().optional(),
+}));
+export async function listVitestTests(cwd) {
+    const result = await sh(`${shq(join(cwd, "node_modules/.bin/vitest"))} list --json`, cwd);
+    if (result.code !== 0) {
+        return { status: "failed", error: (result.stderr || result.stdout || `exit ${result.code}`).trim() };
+    }
+    try {
+        const start = result.stdout.indexOf("[");
+        if (start < 0)
+            return { status: "failed", error: "runner emitted no JSON test listing" };
+        const parsed = VitestListedTestsSchema.safeParse(JSON.parse(result.stdout.slice(start)));
+        return parsed.success
+            ? { status: "listed", tests: parsed.data }
+            : { status: "failed", error: z.prettifyError(parsed.error) };
+    }
+    catch (error) {
+        return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function auditNamedTestOracles(items, listedTests) {
+    const runnerNames = listedTests.map((listed) => ({
+        listed,
+        fullName: listed.name.split(" > ").join(" "),
+    }));
+    return items.flatMap((item) => {
+        if (typeof item !== "object" || item.oracle !== "test")
+            return [];
+        return [{
+                criterion: item.test,
+                // OBS-511: mirror the gate's leaf-anchored suffix rule — this denominator must count
+                // exactly the tests the shipped -t filter would select.
+                matches: runnerNames
+                    .filter(({ fullName }) => fullName === item.test || fullName.endsWith(` ${item.test}`))
+                    .map(({ listed }) => listed),
+            }];
+    });
+}
 function corpusSpecPaths(root) {
     const paths = [];
     const visit = (dir) => {
@@ -116,32 +157,18 @@ function corpusSpecPaths(root) {
 // listing. Every discovered path contributes either all parser-produced acceptance items or one named
 // parse failure; exceptions are evidence, never permission to shrink the corpus silently.
 export function auditAcceptanceCorpus(corpusRoot, listedTests) {
-    const runnerNames = listedTests.map((listed) => ({
-        listed,
-        fullName: listed.name.split(" > ").join(" "),
-    }));
     const results = [];
     for (const specPath of corpusSpecPaths(corpusRoot)) {
         try {
             const graph = compileNative(specPath);
             for (const task of graph.tasks) {
                 for (const item of task.acceptance) {
+                    const namedTest = auditNamedTestOracles([item], listedTests)[0];
                     results.push({
                         specPath,
                         status: "parsed",
                         item,
-                        ...(typeof item === "object" && item.oracle === "test"
-                            ? {
-                                namedTest: {
-                                    criterion: item.test,
-                                    // OBS-511: mirror the gate's leaf-anchored suffix rule — the audit's denominator
-                                    // must count exactly the tests the -t filter would select, or doctor and gate disagree.
-                                    matches: runnerNames
-                                        .filter(({ fullName }) => fullName === item.test || fullName.endsWith(` ${item.test}`))
-                                        .map(({ listed }) => listed),
-                                },
-                            }
-                            : {}),
+                        ...(namedTest ? { namedTest } : {}),
                     });
                 }
             }

package/dist/gates/run-gates.js

@@ -176,11 +176,11 @@ async function coveringTests(worktree, baseRef) {
         }
         const covering = tests.filter((t) => reachOf(t).has(file));
         if (!covering.length)
-            return undefined; // nothing covers this file — only the full suite can speak for it
+            continue; // nothing covers this file — keep every attributable selection already accumulated
         for (const t of covering)
             selected.add(t);
     }
-    return [...selected].sort();
+    return selected.size ? [...selected].sort() : undefined;
 }
 /**
  * The configured test command narrowed to these files. Mirrors testFiltered's `--` rule (acceptance.ts:104):
@@ -287,7 +287,7 @@ export async function runGates(task, ctx) {
         }
         return { results: sorted, commits };
     };
-    const toolGates = ["build", "test", "lint"].filter(enabled);
+    const toolGates = ["build", "lint"].filter(enabled);
     /**
      * v1.87 T5: the shell gates run their commands against the WORKING TREE, while evidence, scope,
      * the judged diff and the merge all read COMMITS. Uncommitted work is therefore visible to
@@ -337,28 +337,28 @@ export async function runGates(task, ctx) {
             + `Uncommitted at round end:\n${dirt}`,
         meta: { dirtyWorktree: true, dirtyAtRoundEnd: true },
     });
-    // build/test/lint vs the shared baseline
-    const runBattery = async (commands, selected) => {
-        if (!toolGates.length)
+    // shell tools vs the shared baseline
+    const runBattery = async (commands, selected, gates = toolGates) => {
+        if (!gates.length)
             return;
         if (!v185) {
-            // ponytail: compareToBaseline batches build/test/lint — their starts are emitted at iteration,
+            // 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.
-            // ponytail: legacy runs build/test/lint in ONE compareToBaseline call, so there is one interval
+            // ponytail: legacy runs adjacent tools in ONE compareToBaseline call, so there is one interval
             // to measure and each of its gates carries it. Split it only if this branch ever stops batching.
             const batchAt = Date.now();
             const batchLoadStart = loadProvider();
-            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, toolGates);
+            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates]);
             const batch = { durationMs: Date.now() - batchAt, load1Start: batchLoadStart, load1End: loadProvider() };
-            for (const g of toolGates)
+            for (const g of gates)
                 spans.set(g, batch);
             // The same refusal AFTER the commands, because a green command can dirty the tree the check
             // above just proved clean. Batched, legacy cannot say WHICH command did it, so the refusal
             // lands on the last gate that had one — the round dies there either way. A red battery is
             // reported as the red it is: the round already ends, and the command output is the better lead.
             const dirt = toolResults.every((r) => r.pass) ? await dirtyWorktree() : undefined;
-            const blame = dirt ? [...toolGates].reverse().find((g) => commands[g]) : undefined;
+            const blame = dirt ? [...gates].reverse().find((g) => commands[g]) : undefined;
             for (const r of toolResults) {
                 await emitStart(r.gate);
                 await record(r.gate === blame ? dirtyRefusal(blame, dirt, commands[blame]) : r);
@@ -366,8 +366,8 @@ export async function runGates(task, ctx) {
             return;
         }
         // T4 (OBS-265): one command at a time, stopping at the first red — a failed build no longer buys
-        // the full vitest suite before anyone reads its verdict.
-        for (const g of toolGates) {
+        // 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]));
             // the screen's interval IS the test gate's first interval, so the split needs no second clock
@@ -437,9 +437,9 @@ export async function runGates(task, ctx) {
      * screen IS the round's verdict: what it produced is journaled (in the order it ran) and the round
      * ends there, so a drive-by out-of-scope edit costs <1s instead of the whole battery.
      *
-     * A green screen changes nothing downstream. The recorded sequence stays GATE_NAMES order, so the
-     * journal, `tickmarkr report`, the surfaces, and resume's GATE_NAMES walk over already-satisfied
-     * gates all keep reading exactly one order.
+     * A green screen changes nothing downstream. The returned record stays in GATE_NAMES order while
+     * the event stream reports the order gates actually ran; resume's GATE_NAMES walk over satisfied
+     * records therefore keeps declaration order without making the live stream lie about execution.
      *
      * ponytail: the price of that is re-reading two git checks (~40ms) in their canonical positions
      * rather than teaching every consumer of the gate stream a second order. Both reads see the same
@@ -447,7 +447,7 @@ export async function runGates(task, ctx) {
      * for. Charge it only when there IS a battery command to protect.
      */
     const screenBlocks = async () => {
-        if (!toolGates.some((g) => ctx.commands[g]))
+        if (!toolGates.some((g) => ctx.commands[g]) && !(enabled("test") && ctx.commands.test))
             return false;
         const screened = [];
         for (const [gate, compute] of [["evidence", evidenceResult], ["scope", scopeResult]]) {
@@ -626,12 +626,7 @@ export async function runGates(task, ctx) {
     }
     if (v185 && await screenBlocks())
         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.
-    const selected = v185 && ctx.selectTests && enabled("test") && ctx.commands.test
-        ? await coveringTests(ctx.worktree, ctx.baseRef)
-        : undefined;
-    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected);
+    await runBattery(ctx.commands);
     if (failed())
         return done();
     if (enabled("evidence")) {
@@ -644,6 +639,14 @@ 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.
+    const selected = v185 && ctx.selectTests && enabled("test") && ctx.commands.test
+        ? await coveringTests(ctx.worktree, ctx.baseRef)
+        : undefined;
+    await runBattery(selected ? { ...ctx.commands, test: testCommandForFiles(ctx.commands.test, selected) } : ctx.commands, selected, enabled("test") ? ["test"] : []);
+    if (failed())
+        return done();
     if (v185 && (enabled("acceptance") || enabled("review"))) {
         // 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

package/package.json

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