tickmarkr 2.1.6 → 2.1.8

package/dist/cli/commands/beat.js

@@ -1,7 +1,7 @@
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { tickmarkrDir } from "../../graph/graph.js";
-import { SUPERVISION_BEAT_MS, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, supervisionStandDownPath, } from "../../run/supervision.js";
+import { SUPERVISION_BEAT_MS, SUPERVISION_DEFAULT_THRESHOLD_PCT, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSupervision, supervisionStandDownPath, } from "../../run/supervision.js";
 // SUP-04: the writer side of supervision, as a VERB. `beatSupervision` and `SUPERVISION_BEAT_MS` shipped
 // with exactly one in-repo caller — the daemon, on one tier — so `status` printed
 // `orchestrator ARMED / overseer ABSENT / watch ABSENT` while a real overseer worked the run: two thirds
@@ -18,16 +18,22 @@ import { SUPERVISION_BEAT_MS, SUPERVISION_STALE_MS, SUPERVISION_TIERS, beatSuper
 // reads UNREADABLE. Here the writes are unguarded: a failure leaves the process with a non-zero exit
 // and a message instead of a claim. The LOOP belongs to the caller, which is what makes the beat
 // evidence: stop calling it and the tier ages into STALE on its own.
+const VALUE_OPTIONS = ["--seat", "--arm-id", "--pct", "--threshold-pct"];
 export async function beat(argv, cwd = process.cwd()) {
     const standDown = argv.includes("--stand-down");
     const seat = seatOf(argv);
-    const named = argv.find((a, i) => !a.startsWith("--") && argv[i - 1] !== "--seat");
+    const pct = percentageOf(argv, "--pct");
+    const thresholdPct = percentageOf(argv, "--threshold-pct") ?? SUPERVISION_DEFAULT_THRESHOLD_PCT;
+    const armId = optionOf(argv, "--arm-id");
+    const named = argv.find((a, i) => !a.startsWith("--") && !VALUE_OPTIONS.includes(argv[i - 1] ?? ""));
     if (!isTier(named)) {
-        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> [--stand-down] — got ${named ? `\`${named}\`` : "no tier"}`);
+        throw new Error(`usage: tickmarkr beat <${SUPERVISION_TIERS.join("|")}> --seat <identity> ` +
+            `[--arm-id <identity> --pct <0..100> --threshold-pct <0..100>] [--stand-down] — ` +
+            `got ${named ? `\`${named}\`` : "no tier"}`);
     }
     // SUP-05: NO SEAT, NO BEAT — and the refusal comes before any write, so a refused invocation leaves
-    // the tier exactly as it found it. This verb is one-shot: the pid it would otherwise record has
-    // already exited by the time anyone reads the record, so tier + pid + instant is a beat nobody can
+    // the tier exactly as it found it. This verb is one-shot: the exitedWriterPid it records has
+    // already exited by the time anyone reads the record, so tier + writer + instant is a beat nobody can
     // attribute to a seat. Measured 2026-08-26: a consult seat ran the documented loop verbatim and the
     // board read that tier ARMED with no seat of that tier having armed anything, and a seatless ARMED
     // reads as coverage — worse than ABSENT, because ABSENT sends someone to look.
@@ -42,16 +48,35 @@ export async function beat(argv, cwd = process.cwd()) {
     // uncleared marker would render DISARMED while this verb claimed ARMED, so the removal is unguarded
     // too — `force` makes the ordinary "no marker" case a no-op, and anything else is a real failure.
     rmSync(supervisionStandDownPath(cwd, named), { force: true, recursive: true });
-    beatSupervision(cwd, named, seat);
+    beatSupervision(cwd, named, seat, pct === undefined ? undefined : { armId: armId ?? seat, pct, thresholdPct });
     return `${named} ARMED as ${seat} — beat again every ${SUPERVISION_BEAT_MS / 1_000}s; the tier reads STALE ${SUPERVISION_STALE_MS / 1_000}s after the last beat`;
 }
 /** `--seat <identity>` or `--seat=<identity>`; blank and missing are the same answer — none. */
 function seatOf(argv) {
-    const inline = argv.find((a) => a.startsWith("--seat="))?.slice("--seat=".length);
-    const spaced = argv[argv.indexOf("--seat") + 1];
-    const seat = (inline ?? (argv.includes("--seat") ? spaced : undefined))?.trim();
+    const seat = optionOf(argv, "--seat")?.trim();
     return seat && !seat.startsWith("--") ? seat : undefined;
 }
+/** A `--name value` or `--name=value` option, excluding a missing value or the next flag. */
+function optionOf(argv, name) {
+    const inline = argv.find((a) => a.startsWith(`${name}=`))?.slice(name.length + 1).trim();
+    const spaced = argv[argv.indexOf(name) + 1]?.trim();
+    const value = inline ?? (argv.includes(name) ? spaced : undefined);
+    return value && !value.startsWith("--") ? value : undefined;
+}
+function percentageOf(argv, name) {
+    const raw = optionOf(argv, name);
+    if (raw === undefined) {
+        if (argv.includes(name) || argv.some((a) => a.startsWith(`${name}=`))) {
+            throw new Error(`${name} needs a number from 0 through 100`);
+        }
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0 || value > 100) {
+        throw new Error(`${name} must be a number from 0 through 100`);
+    }
+    return value;
+}
 // Stand-down is a RECORDED act, not a silence: the marker tells a reader this watcher left on purpose,
 // so the tier reads DISARMED rather than ageing out as a death. Published atomically — written aside,
 // renamed over — because a torn marker is rejected by the reader, and a rejected stand-down reports a
@@ -63,7 +88,9 @@ function standDownTier(repoRoot, tier, seat) {
     mkdirSync(dirname(p), { recursive: true });
     // The marker names the seat for the same reason the beat does: "someone stood this tier down" is not
     // a hand-off anyone can act on, and on a seat tier the reader rejects an anonymous one outright.
-    writeFileSync(tmp, JSON.stringify({ tier, seat, pid: process.pid, disarmedAt: new Date().toISOString() }) + "\n");
+    writeFileSync(tmp, JSON.stringify({
+        tier, seat, exitedWriterPid: process.pid, disarmedAt: new Date().toISOString(),
+    }) + "\n");
     renameSync(tmp, p);
     return `${tier} DISARMED — ${seat} handed off; status reads it stood down, not dead`;
 }

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/run.js

@@ -167,7 +167,7 @@ const railTone = (event, fallback) => {
     // `gate-result` is the one event whose data IS a gate result; every other row carrying a `gate`
     // names a gate without reporting one (a start, a reuse, a retry) and keeps its declared tone.
     if (event.event === "gate-result")
-        return GATE_OUTCOME_TONES[normalizeGateOutcome(event.data).kind] ?? fallback;
+        return GATE_OUTCOME_TONES[normalizeGateOutcome(event.data).kind];
     const verdict = event.data.pass ?? event.data.ok;
     return verdict === true ? "pass" : verdict === false ? "fail" : fallback;
 };
@@ -226,7 +226,24 @@ const railSalient = (data) => RAIL_SALIENT.flatMap(({ key, render }) => {
  * This is one detail vocabulary stated twice, so `brand-surfaces.test.ts` pins the two against each
  * other over the whole event corpus: the pipe's bytes must equal event/taskId/THIS detail put through
  * the formatter's legacy squeeze-and-slice. A ladder that drifts fails there rather than in a tab.
+ * Gate-result verdict words are the deliberate exception: the pipe is byte-frozen, while the TTY rail
+ * names the normalized outcome so a held selected-test screen is not narrated as a pass.
  */
+const gateResultDetail = (data) => {
+    if (typeof data.gate !== "string")
+        return undefined;
+    switch (normalizeGateOutcome(data).kind) {
+        case "passed":
+            return `${data.gate} passed`;
+        case "failed":
+            return `${data.gate} failed`;
+        case "held":
+            // The kind is already normalized; the selected-test list only chooses this surface noun.
+            return Array.isArray(data.selectedTests) ? `${data.gate} selected-test screen` : `${data.gate} held`;
+        default:
+            return data.gate;
+    }
+};
 const formatterDetail = ({ event, data }) => {
     const assignment = data.assignment;
     const direct = [data.summary, data.reason, data.error, data.step, data.action, data.lint, data.branch, data.from]
@@ -240,7 +257,9 @@ const formatterDetail = ({ event, data }) => {
         }
         if (event === "tip-verify")
             return `${data.gate} passed`;
-        return `${data.gate}${data.pass === true ? " passed" : data.pass === false ? " failed" : ""}`;
+        if (event === "gate-result")
+            return gateResultDetail(data);
+        return `${data.gate}`;
     }
     if (typeof data.code === "number")
         return `exit ${data.code}`;

package/dist/cli/commands/stats.js

@@ -1,8 +1,8 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { classifyFailureOutput } from "../../gates/baseline.js";
 import { stateDirName } from "../../graph/graph.js";
 import { Journal } from "../../run/journal.js";
+import { normalizeGateOutcome } from "../../run/outcome.js";
 // The operator-facing schema is deliberately closed. Adding a fact to the table therefore requires
 // adding it here as a conscious compatibility change, rather than letting incidental journal fields
 // leak into an analytics surface.
@@ -35,14 +35,6 @@ const reviewerFrom = (data) => {
         return undefined;
     return /\breviewer(?:\s+|:\s*)([\w@./+-]+:[\w@./+-]+)/iu.exec(data.details)?.[1];
 };
-const redEvidence = (data) => {
-    const fingerprints = Array.isArray(data.fingerprints)
-        ? data.fingerprints.filter((value) => typeof value === "string")
-        : [];
-    const prose = [data.details, data.error, data.reason]
-        .filter((value) => typeof value === "string");
-    return [...fingerprints, ...prose].join("\n");
-};
 const historyFor = (tasks, taskId) => {
     let history = tasks.get(taskId);
     if (!history) {
@@ -143,12 +135,10 @@ export function collectChannelStats(cwd = process.cwd()) {
                 if (reviewer)
                     channel.reviewers.add(reviewer);
             }
-            if (event.data.pass !== false)
-                continue;
-            const infra = event.data.infra === true || classifyFailureOutput(redEvidence(event.data)) === "infra";
-            if (infra)
+            const outcome = normalizeGateOutcome(event.data);
+            if (outcome.kind === "infra")
                 channel.infraReds += 1;
-            else
+            else if (outcome.kind === "failed")
                 channel.realReds += 1;
         }
         // A rescue is task-matched, not attempt-matched: one edge says the failed author and delivering

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,12 +7,12 @@ 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";
-import { armSupervision, readSupervision, supervisionText } from "../../run/supervision.js";
+import { armWatchSupervision, readSupervision, supervisionText } from "../../run/supervision.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
 import { COCKPIT_COLUMN_FLOOR } from "../../tui/cockpit/layout.js";
 import { cellWidth, fitCells, wrapCells } from "../../tui/cockpit/width.js";
@@ -109,6 +109,15 @@ const ASCII_SPINNER = ["|", "/", "-", "\\"];
 const SAVE_TERMINAL_TITLE = "\x1b[22;0t";
 const RESTORE_TERMINAL_TITLE = "\x1b[23;0t";
 const decisionEvidence = (stateDir, runId, sequence) => `${stateDir}/runs/${runId}/journal.jsonl#L${sequence}`;
+const DECISION_GATE_VERDICTS = {
+    passed: "passed",
+    failed: "failed",
+    skipped: "skipped",
+    declined: "skipped",
+    held: "unknown",
+    unavailable: "unknown",
+    infra: "unknown",
+};
 // v1.79 T4: a deterministic JSONL projection over journal truth. Sequence/evidence come from the
 // append-only line position, timestamps and claims come from the row, and no watcher-local clock or
 // filesystem write participates. Re-reading the same bytes therefore returns the same event bytes.
@@ -126,13 +135,7 @@ export const decisionEventsFromJournal = (events, runId, stateDir = ".tickmarkr"
         return [{ ...base, type: "phase-change", tier: "routine", phase: event.data.phase }];
     }
     if (event.event === "gate-result" && typeof event.data.gate === "string") {
-        const verdict = event.data.skipped === true
-            ? "skipped"
-            : event.data.pass === true
-                ? "passed"
-                : event.data.pass === false
-                    ? "failed"
-                    : "unknown";
+        const verdict = DECISION_GATE_VERDICTS[normalizeGateOutcome(event.data).kind];
         return [{
                 ...base,
                 type: "gate-verdict",
@@ -381,6 +384,13 @@ export const gateBox = (state, unicode) => {
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
 export const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
+const GATE_OUTCOME_STATES = {
+    // The board state is a rendering vocabulary over the normalized outcome, not another field reader.
+    passed: "pass",
+    failed: "fail",
+    skipped: "skip",
+    declined: "skip",
+};
 const gateSnapshot = (task, events, rehashAt) => {
     const outcomes = new Map();
     const start = attemptStartIdx(events, task.id);
@@ -389,12 +399,9 @@ const gateSnapshot = (task, events, rehashAt) => {
             const e = events[eventIndex];
             if (e.taskId !== task.id || e.event !== "gate-result" || typeof e.data.gate !== "string")
                 continue;
-            if (e.data.skipped === true)
-                outcomes.set(e.data.gate, { state: "skip", eventIndex });
-            else if (e.data.pass === true)
-                outcomes.set(e.data.gate, { state: "pass", eventIndex });
-            else if (e.data.pass === false)
-                outcomes.set(e.data.gate, { state: "fail", eventIndex });
+            const state = GATE_OUTCOME_STATES[normalizeGateOutcome(e.data).kind];
+            if (state)
+                outcomes.set(e.data.gate, { state, eventIndex });
         }
     }
     return {
@@ -519,7 +526,7 @@ const foldTaskEffort = (tasks, events) => {
             task.dispatches += 1;
         else if (event.event === "gate-result" && event.data.gate === "review"
             && event.data.replayMeasurement !== true
-            && REVIEW_VERDICTS.has(normalizeGateOutcome(event.data.outcome ?? event.data).kind))
+            && REVIEW_VERDICTS.has(normalizeGateOutcome(event.data).kind))
             task.reviews += 1;
         else if (event.event === "task-human")
             task.parks += 1;
@@ -843,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.
@@ -1373,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))
@@ -1408,7 +1455,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     // it INVERTS it: armSupervision's interval outlives the board in any host that outlives one board, so
     // a dead board keeps writing and reads ARMED. That is the over-claiming direction, the one an operator
     // acts on, and the one this instrument exists to close.
-    const armed = bounded ? undefined : armSupervision(cwd, "watch", opts.supervisionBeatMs);
+    const armed = bounded ? undefined : armWatchSupervision(cwd, opts.supervisionBeatMs);
     let titleSaved = false;
     const restoreTitle = () => {
         if (!titleSaved)

package/dist/compile/index.d.ts

@@ -10,6 +10,6 @@ export type PlanIR = {
     tasks: RunGraph["tasks"];
 };
 export type PlanFinalizationHook = (plan: PlanIR) => PlanIR;
-export declare function finalizePlan(plan: PlanIR, src: string): RunGraph;
+export declare function finalizePlan(plan: PlanIR, src: string, repoRoot?: string): RunGraph;
 export declare function compileSource(src: string, type?: SourceType, root?: string, beforeFinalize?: PlanFinalizationHook): RunGraph;
 export {};

package/dist/compile/index.js

@@ -2,6 +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 { 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";
@@ -40,8 +41,8 @@ function enforceTaskUnitContract(g, src) {
     }
     return g;
 }
-export function finalizePlan(plan, src) {
-    const graph = validateGraph({
+export function finalizePlan(plan, src, repoRoot) {
+    const graph = enforceTaskUnitContract(validateGraph({
         version: plan.version,
         ...(plan.mode !== undefined ? { mode: plan.mode } : {}),
         spec: {
@@ -51,8 +52,26 @@ export function finalizePlan(plan, src) {
             ...(plan.base !== undefined ? { base: plan.base } : {}),
         },
         tasks: plan.tasks,
-    });
-    return enforceTaskUnitContract(graph, src);
+    }), src);
+    // 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) {
+        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;
 }
 function compilePlan(src, type, root) {
     const kind = type ?? detect(src);
@@ -75,5 +94,5 @@ function compilePlan(src, type, root) {
     };
 }
 export function compileSource(src, type, root, beforeFinalize = (plan) => plan) {
-    return finalizePlan(beforeFinalize(compilePlan(src, type, root)), src);
+    return finalizePlan(beforeFinalize(compilePlan(src, type, root)), src, root);
 }