tickmarkr 2.1.7 → 2.1.9

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,36 @@ 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.
+    - SPIKE-THE-CONTRACT-THEN-SCOPE trigger question: COULD A TEST THIS TASK DOES NOT OWN BE ASSERTING THE
+      THING I AM CHANGING? "I'D HAVE TO GREP TO KNOW" IS YES. This applies to observable contracts:
+      execution order, event-stream order, diagnostics/output sets, CLI surface, serialised formats, or
+      timing measurements. If yes, implement the change as a throwaway spike, run the full suite, read the
+      reds, THEN scope files[].
+    - Caveat: a spike measures ONE implementation. It converts unknown collateral into
+      measured-for-one-specimen collateral; it does NOT make its reds the closed blocker set for every
+      route. A worker taking a different route can still red on unowned collateral; that remains a PLAN
+      DEFECT, NEVER A RETRY.
+    - Measured price: 518 s implement + 831 s suite = 1,348 s ≈ 22.5 min. "Far cheaper than the alternative"
+      is WITHDRAWN on the direct leg: a direct failed run died at about 20 min, so on the direct leg the
+      two are EQUAL. The spike only pays when it avoids downstream halt, sweep, re-scope, rulings, and
+      another compile+plan.
+    - Do NOT run the spike for a change that is purely additive and unwinds cheaply. The rule is bounded by
+      the expense of a late defect, not by novelty; where the defect would surface and fix cheaply, the spike
+      is pure overhead.
+
   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/drivers/herdr.d.ts

@@ -1,5 +1,5 @@
 import { type JournalEvent } from "../run/journal.js";
-import { type ExecutorDriver, type NotifyOpts, type Slot, type SlotOpts } from "./types.js";
+import { type ExecutorDriver, type NotifyOpts, type PanesToCloseOpts, type Slot, type SlotOpts } from "./types.js";
 export declare const TRAILER_SAFE_FLOOR_COLS = 108;
 export declare const TRAILER_WIDTH_MARGIN = 2;
 export declare const DELIVERY_ATTEMPTS = 3;
@@ -70,6 +70,11 @@ export declare class HerdrDriver implements ExecutorDriver {
     private watches;
     constructor(bin?: string, workersPerTab?: number, time?: HerdrTimeSource, journal?: DriverJournal | undefined);
     private appendDispatchRetry;
+    private openRunJournal;
+    private liveSupervisionSeats;
+    private journalReconcile;
+    private paneReconcileData;
+    private parsePaneList;
     /** v1.99 T2: bind this driver's own journal writes to the run's live narration sink. */
     narrateWith(narrate: (event: JournalEvent) => void): void;
     private serial;
@@ -123,9 +128,6 @@ export declare class HerdrDriver implements ExecutorDriver {
     private watchSlot;
     private discardSplit;
     narrator(cwd: string, command: string, runId?: string): Promise<Slot>;
-    reconcile(desired: Set<string>, runId: string, opts?: {
-        spareLiveLlm?: boolean;
-        endedRunIds?: Set<string>;
-    }): Promise<void>;
+    reconcile(desired: Set<string>, runId: string, opts?: PanesToCloseOpts): Promise<void>;
     worktree(repo: string, branch: string, baseRef: string): Promise<string>;
 }