tickmarkr 2.4.0 → 2.4.2

package/dist/cli/commands/doctor.js

@@ -15,13 +15,14 @@ import { HerdrDriver } from "../../drivers/herdr.js";
 import { ORCA_FIXTURE_VERSION, parseEnvelope, resolveOrcaCliBinary } from "../../drivers/orca.js";
 import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
-import { CATALOG_REFRESH_TIMEOUT_MS, LIVEBENCH_TABLE_DATE, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
+import { CATALOG_REFRESH_TIMEOUT_MS, LIVEBENCH_TABLE_DATE, formatCatalogRefreshLegs, 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";
 export const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
+const initialFetch = globalThis.fetch;
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
@@ -348,19 +349,23 @@ export function liveBenchStalenessFinding(now) {
 }
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     if (_argv.length === 1 && _argv[0] === "--refresh-catalog") {
-        const refreshed = await refreshCatalogCommand({ repoRoot: cwd, now: opts.catalogNow });
+        const refreshed = await refreshCatalogCommand({ repoRoot: cwd, fetcher: opts.catalogFetcher, now: opts.catalogNow });
         return refreshed.updated
-            ? `tickmarkr doctor --refresh-catalog: model catalog refreshed${refreshed.warning ? `; ${refreshed.warning}` : ""}`
-            : `tickmarkr doctor --refresh-catalog: catalog refresh unavailable — ${refreshed.warning ?? "unknown failure"}; retained ${refreshed.catalog.source} catalog`;
+            ? `tickmarkr doctor --refresh-catalog: model catalog refreshed — ${formatCatalogRefreshLegs(refreshed.legs)}${refreshed.warning ? `; ${refreshed.warning}` : ""}`
+            : `tickmarkr doctor --refresh-catalog: catalog refresh unavailable — ${formatCatalogRefreshLegs(refreshed.legs)}${refreshed.warning ? `; ${refreshed.warning}` : ""}`;
     }
     // Operator directive 2026-08-12 (declutter): long per-model lists render only when asked for.
     const listAllModels = _argv.includes("--models");
     const cfg = loadConfig(cwd);
     let catalog = opts.catalog ?? readCachedCatalog(cwd, { now: opts.catalogNow });
-    let catalogRefreshWarning;
+    let catalogRefreshLine;
     // RULING-222-17 reverses cache-only for these two operator-facing commands only. The refresh
     // remains age-guarded; compile, plan, and run never import this path.
-    if (!opts.catalog && catalog.source === "cache" && catalog.stale) {
+    const catalogRefreshAllowed = process.env.VITEST !== "true"
+        || opts.catalogFetcher !== undefined
+        || opts.catalogNow !== undefined
+        || globalThis.fetch !== initialFetch;
+    if (!opts.catalog && catalog.stale && catalogRefreshAllowed) {
         const refreshed = await refreshCatalogCommand({
             repoRoot: cwd,
             fetcher: opts.catalogFetcher,
@@ -368,7 +373,7 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             now: opts.catalogNow,
         });
         catalog = refreshed.catalog;
-        catalogRefreshWarning = refreshed.warning;
+        catalogRefreshLine = formatCatalogRefreshLegs(refreshed.legs);
     }
     // banner at START — the logo greets the operator before the ~60s probe wait, never trailing it (operator report 2026-07-17)
     if (opts.banner !== false && visual())
@@ -466,8 +471,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     if (catalog.warning) {
         rows.push(attentionRow(`model catalog cache unreadable — ${catalog.warning}; using vendored fallback (advisory — routing unchanged)`));
     }
-    if (catalogRefreshWarning) {
-        rows.push(attentionRow(`model catalog auto-refresh failed open — ${catalogRefreshWarning}; retained ${catalog.source} catalog`));
+    if (catalogRefreshLine) {
+        rows.push(attentionRow(`model catalog auto-refresh — ${catalogRefreshLine}`));
     }
     // v1.48 T1 / v1.86 T12: advisory sweep for known agent CLIs with no drive contract. Presence is
     // resolved through the worker's login shell; advisory targets are never executed or written to health.

package/dist/cli/commands/fleet.js

@@ -3,7 +3,7 @@ import { dirname } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, modelAuthExclusions } from "../../adapters/registry.js";
 import { catalogModelAdvisory, catalogTierRanking, declaredModelWindow, fleetUnclassifiedModels } from "../../adapters/model-lints.js";
-import { CATALOG_REFRESH_TIMEOUT_MS, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
+import { CATALOG_REFRESH_TIMEOUT_MS, formatCatalogRefreshLegs, readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog-remote.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, readClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { fleetEditableFromConfig, fleetEditableEquals, formatFleetPrint, globalConfigDir, overlayBytesLoadError, renderFleetOverlayWrite, repoOverlayPath, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
 import { projectFleetWhy, renderFleetWhy } from "../../config/fleet-why.js";
@@ -14,6 +14,7 @@ import { route } from "../../route/router.js";
 import { disallowedBy } from "../../route/preference.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { loadRoutingProfile } from "../../run/journal.js";
+const initialFetch = globalThis.fetch;
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
 const QUIT = "fleet: quit without writing";
 // v1.60 T3: every preview surface ranks with the SAME exploration setting as the candidate picker
@@ -98,16 +99,21 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     const interactive = input.isTTY === true && output.isTTY === true;
     let catalog = readCachedCatalog(cwd, { now: io.catalogNow });
     let refreshReason = "";
-    if (catalog.source === "cache" && catalog.stale) {
+    let catalogRefreshAttempted = false;
+    const catalogRefreshAllowed = process.env.VITEST !== "true"
+        || io.catalogFetcher !== undefined
+        || io.catalogNow !== undefined
+        || globalThis.fetch !== initialFetch;
+    if (catalog.stale && catalogRefreshAllowed) {
         const refreshed = await refreshCatalogCommand({
             repoRoot: cwd,
             fetcher: io.catalogFetcher,
             timeoutMs: CATALOG_REFRESH_TIMEOUT_MS,
             now: io.catalogNow,
         });
+        catalogRefreshAttempted = true;
         catalog = refreshed.catalog;
-        if (refreshed.warning)
-            refreshReason = `fleet: catalog auto-refresh failed open — ${refreshed.warning}; retained ${catalog.source} catalog`;
+        refreshReason = `fleet: catalog auto-refresh — ${formatCatalogRefreshLegs(refreshed.legs)}`;
     }
     if (print) {
         // v1.51 T4: the print surface names the mode and its source layer right under the header —
@@ -129,7 +135,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     if (!why && interactive) {
         const { reuse } = initDoctorReuse(cwd, values.fresh ?? false);
         if (!reuse) {
-            output.write(`${await doctor([], cwd, adapters, { banner: false, compact: true })}\n`);
+            output.write(`${await doctor([], cwd, adapters, { banner: false, compact: true, ...(catalogRefreshAttempted ? { catalog } : {}), catalogFetcher: io.catalogFetcher, catalogNow: io.catalogNow })}\n`);
         }
     }
     const assembled = await assembleFleetEditor(cwd, adapters, io, { globalDir, catalog });

package/dist/cli/commands/init.js

@@ -11,6 +11,7 @@ import { BANNER, kvRow, legend, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
 import { orcaHostDetected } from "../../drivers/index.js";
 import { Journal } from "../../run/journal.js";
+import { runLockRunId, runStatusLine } from "../../run/lock.js";
 import { doctor } from "./doctor.js";
 import { assembleFleetEditor } from "./fleet.js";
 const SCAFFOLD_SPEC = "tickmarkr.spec.md";
@@ -24,20 +25,18 @@ const ENVIRONMENTS_FOOTER = [
     "  claude code — tickmarkr init --agent installs the /tkr skills + AGENTS.md so Claude Code (or any agent CLI) drives the loop natively",
     "  anywhere — no herdr or Orca terminal? same fail-closed gates, headless subprocess driver (legacy: no herdr? same fail-closed gates, headless subprocess driver when Orca markers are absent)",
 ].join("\n");
-/** Latest journal without a run-end event, if any. */
-function activeRunId(cwd) {
-    const runId = Journal.latestRunId(cwd, { withJournal: true });
+/** Current run truth, lock first; falls back to an abandoned journal. */
+function activeRunLine(cwd) {
+    const locked = runLockRunId(cwd);
+    const runId = locked ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
         return null;
+    let events = [];
     try {
-        const events = Journal.open(cwd, runId).read();
-        if (events.some((e) => e.event === "run-end"))
-            return null;
-        return runId;
-    }
-    catch {
-        return null;
+        events = Journal.open(cwd, runId).read();
     }
+    catch { /* lock may exist before first journal row */ }
+    return runStatusLine(cwd, runId, events);
 }
 /** Relative paths of specs/*.spec.md already in the repo. */
 function existingSpecs(cwd) {
@@ -56,9 +55,9 @@ function existingSpecs(cwd) {
 }
 /** Context-aware next-steps line (operator-approved 2026-07-17). */
 function nextSteps(cwd, scaffoldedSpec) {
-    const runId = activeRunId(cwd);
-    if (runId)
-        return `run ${runId} active — tickmarkr status`;
+    const runLine = activeRunLine(cwd);
+    if (runLine)
+        return `${runLine} — tickmarkr status`;
     const specs = existingSpecs(cwd);
     if (specs.length > 0) {
         const listed = specs.length <= 3 ? specs.join(", ") : `${specs.slice(0, 3).join(", ")}, …`;

package/dist/cli/commands/plan.js

@@ -6,7 +6,7 @@ import { formatModelAuthLine, contextWindowLints, modelLints, preferEntryLints,
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 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 { DEFAULT_CONFIG, effectiveReviewPolicy, 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";
@@ -14,11 +14,12 @@ import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines }
 import { staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
-import { modelId, modelProvider } from "../../gates/review.js";
-import { loadRoutingProfile } from "../../run/journal.js";
+import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
+import { Journal, loadRoutingProfile } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
-import { shq } from "../../adapters/types.js";
+import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
+import { runLockRunId, runStatusLine } from "../../run/lock.js";
 import { driverEvidence, pickDriver } from "../../drivers/index.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).
@@ -44,6 +45,19 @@ const fleetCanCrossVendorReview = (channels) => {
     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;
+const judgeOracle = (task) => task.acceptance.some((item) => typeof item === "string" || (typeof item === "object" && item.oracle === "judge"));
+const latestRunStatusLine = (cwd) => {
+    const locked = runLockRunId(cwd);
+    const runId = locked ?? Journal.latestRunId(cwd, { withJournal: true });
+    if (!runId)
+        return null;
+    let events = [];
+    try {
+        events = Journal.open(cwd, runId).read();
+    }
+    catch { /* lock may exist before first journal row */ }
+    return runStatusLine(cwd, runId, events);
+};
 async function taskInputFindings(tasks, cwd) {
     const pathsByTask = tasks.map((task) => {
         const paths = new Set(task.files.map((path) => path.replace(/^\.\//, "")));
@@ -169,11 +183,13 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     // source, and the explore posture; each task row carries a floor-derivation line below.
     // v1.89 T4: the harness names itself ABOVE the routing table — the table is only as trustworthy as the
     // binary that produced it, and version equality cannot tell an installed package from a checkout.
+    const runLine = latestRunStatusLine(cwd);
     const lines = [
         `tickmarkr plan — dry run (${channels.length} channels available)`,
         `mode: ${mode.mode} (${source}) · explore ${cfg.routing.explore?.mode ?? "on"}`,
         `driver: ${driverEvidence(cfg, selectedDriver, values.driver)}`,
         harnessLine(resolveHarness(harnessFrom)),
+        ...(runLine ? [runLine] : []),
         "",
     ];
     const judgeDeny = disallowedBy(cfg.judge, cfg.routing, "judge");
@@ -273,6 +289,28 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         lints.push("review: no cross-vendor reviewer pair in fleet — set review.required: false to waive");
     }
     let cost = 0;
+    const seatCost = (seat) => seat?.channel === "api" ? cfg.pricing[seat.tier] : 0;
+    const judgeSeat = (task) => {
+        const shapeGates = cfg.gates.byShape?.[task.shape];
+        if (!task.gates.includes("acceptance") || shapeGates?.acceptance === false)
+            return { line: "none — acceptance gate disabled", cost: 0 };
+        if (!judgeOracle(task))
+            return { line: "none — no judge oracle", cost: 0 };
+        const seat = pools.judge.find((c) => c.adapter === cfg.judge.adapter && c.model === cfg.judge.model);
+        return { line: `${cfg.judge.adapter}:${cfg.judge.model}`, cost: seatCost(seat) };
+    };
+    const reviewSeat = (task, author) => {
+        const shapeGates = cfg.gates.byShape?.[task.shape];
+        if (!task.gates.includes("review") || shapeGates?.review === false)
+            return { line: "none — review gate disabled", cost: 0 };
+        const policy = effectiveReviewPolicy(task.files, cfg.review);
+        if (policy === "judge-only")
+            return { line: "none — reviewPolicy judge-only: declared leaf paths", cost: 0 };
+        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor);
+        if (!reviewer)
+            return { line: "none — no cross-vendor reviewer available", cost: 0 };
+        return { line: `${channelKey(reviewer)} — reviewPolicy full`, cost: seatCost(reviewer) };
+    };
     const routed = [];
     for (const t of g.tasks) {
         const refusals = [...(oracleRefusals.get(t.id) ?? []), ...(inputRefusals.get(t.id) ?? [])];
@@ -288,8 +326,10 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
                 lints.push(suf ? `${l}${suf}` : l);
             }
             const est = r.assignment.channel === "sub" ? 0 : cfg.pricing[r.assignment.tier];
-            cost += est;
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`);
+            const judge = judgeSeat(t);
+            const review = reviewSeat(t, r.assignment);
+            cost += est + judge.cost + review.cost;
+            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`, `    judge: ${judge.line}${judge.cost ? ` ~$${judge.cost.toFixed(2)}` : ""}`, `    review: ${review.line}${review.cost ? ` ~$${review.cost.toFixed(2)}` : ""}`);
             const d = derivation(t.shape);
             if (d)
                 lines.push(d);
@@ -326,7 +366,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     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`);
+    lines.push("", `est. cost (API LLM seats, rough): ~$${cost.toFixed(2)} + consult calls`);
     // VIS-04: summary only when a profile is active AND something deviates. Labeled by the switch — off = preview.
     if (profile && deviations) {
         lines.push(cfg.routing.learned === "off"

package/dist/cli/commands/run.js

@@ -2,7 +2,7 @@ import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, probeAll, readDoctor } from "../../adapters/registry.js";
 import { ROUTING_MODES } from "../../config/config.js";
 import { parseDriverOverride, pickDriver } from "../../drivers/index.js";
-import { loadGraph } from "../../graph/graph.js";
+import { loadGraph, onDiskSpecHash, readCompileRefusal } from "../../graph/graph.js";
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
 import { isRunLockLive } from "../../run/lock.js";
 import { route, NO_EXPLORE_ENV } from "../../route/router.js";
@@ -424,7 +424,26 @@ export async function run(argv, cwd = process.cwd()) {
     if (values.quality)
         console.warn(QUALITY_ALIAS_NOTICE);
     const flagMode = values.mode ?? (values.quality ? "partner-led" : undefined);
+    const refusal = (() => {
+        try {
+            return readCompileRefusal(cwd);
+        }
+        catch (error) {
+            throw new Error(`refusing to run: ${error instanceof Error ? error.message : String(error)}. `
+                + "Recompile successfully with `tickmarkr compile <src>` before running.");
+        }
+    })();
+    if (refusal) {
+        throw new Error(`refusing to run the prior graph: the last compile of ${refusal.source} was refused at ${refusal.refusedAt}:\n`
+            + `${refusal.error}\n`
+            + "Recompile successfully with `tickmarkr compile <src>` to clear the refusal record before running.");
+    }
     const graph = loadGraph(cwd);
+    const diskSpec = onDiskSpecHash(cwd, graph);
+    if (diskSpec && diskSpec.hash !== graph.spec.hash) {
+        throw new Error(`refusing to run a stale graph: ${diskSpec.path} content hash ${diskSpec.hash} differs from `
+            + `the graph's recorded spec hash ${graph.spec.hash}. Recompile with \`tickmarkr compile <src>\` before running.`);
+    }
     const { cfg, conflict } = resolveRunMode(cwd, { flag: flagMode, spec: graph.mode });
     if (conflict) {
         // Loud, never silent: live intent (the flag) may override compiled intent (the spec) — strict refuses.

package/dist/cli/commands/status.js

@@ -9,7 +9,7 @@ import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../.
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
-import { isPidLive, runLockOwner } from "../../run/lock.js";
+import { isPidLive, runLockRunId, runStatusLine } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
 import { normalizeStallSnapshot } from "../../run/stall.js";
@@ -860,17 +860,6 @@ const parseJournalSnapshot = (raw) => raw.split("\n").flatMap((line) => {
 // .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 {
@@ -900,7 +889,7 @@ const readRunJournalRaw = (cwd, runId, allowMissingJournal) => {
 const readRunRecord = (cwd, graph, namedRunId) => {
     const explicitRunId = namedRunId === undefined ? undefined : parseRunId(namedRunId);
     const lockedRunId = explicitRunId === undefined && canReadRunLockOwner(cwd)
-        ? reportableLockRunId(runLockOwner(cwd))
+        ? runLockRunId(cwd)
         : undefined;
     const runId = explicitRunId ?? lockedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
     if (!runId)
@@ -947,6 +936,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const record = readRunRecord(cwd, g, namedRunId);
     const runId = record?.runId;
     const events = record?.events ?? [];
+    const runLine = runId && record ? runStatusLine(cwd, runId, events) : null;
     // The header and every live-phase consumer share this exact process reading. Proved death retires
     // stale phase markers; unknown identity deliberately does not, preserving pre-identity journals.
     const daemon = daemonLiveness(events);
@@ -1091,7 +1081,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
-            ? `tickmarkr status${divider}run ${runId}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, daemon, now).replaceAll(" · ", divider)}${verify ? `${divider}${verify}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
+            ? `tickmarkr status${divider}${runLine ?? `run ${runId}`}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, daemon, now).replaceAll(" · ", divider)}${verify ? `${divider}${verify}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
             : `tickmarkr status${zone}${divider}no runs yet${divider}${done}/${total} done`;
         const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
         return {
@@ -1115,7 +1105,8 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const tally = tipPhase
         ? `${progressTone(`${progressGlyph} ${done}/${total} tasks done`)}${dot}${progressTone("run not verified")}`
         : done === total && total > 0 ? ok(`${done}/${total} done`) : information(`${done}/${total} done`);
-    const live = `${liveness(events, daemon, now)} · load1 ${os.loadavg()[0].toFixed(2)}`
+    const load1 = os.loadavg()[0] ?? 0;
+    const live = `${liveness(events, daemon, now)} · load1 ${load1.toFixed(2)}`
         .replace(/\bdead\b/u, fail("dead"))
         .replace(/\bfinished\b/u, dim("finished"))
         .replace(/\balive\b/u, running("alive"))
@@ -1133,6 +1124,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
                     ? ok(verify)
                     : tipFailed ? fail(`${GLYPHS.fail} ${verify}`) : warn(`${GLYPHS.attention} ${verify}`)]),
         ...(runId ? [live] : []),
+        ...(runLine && runLine !== `run ${runId}` ? [runLine] : []),
         ...(journalRowsOnly ? [`zone ${localZoneLabel(zoneReference)}`] : []),
     ].join(separator);
     // The brand lockup is two rows and stays two rows at every width: the muted chip, and the running
@@ -1427,7 +1419,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         // 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))
+            ? runLockRunId(cwd)
             : undefined;
         const runId = explicitRunId ?? lockedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
         if (!runId)
@@ -1494,16 +1486,22 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         process.stdout.write(`\x1b]0;⏳ ${hotPhase.taskId} ${phaseLabel(hotPhase)} ${fmtElapsed(nowMs - hotPhase.startedAt)}\x07`);
     };
     const signalHandlers = [];
+    let exitingFromSignal = false;
     const exitFromSignal = (code) => () => {
+        if (exitingFromSignal)
+            return;
+        exitingFromSignal = true;
         if (titleSaved) {
             process.removeListener("exit", restoreTitle);
             restoreTitle();
         }
-        if (alternateScreen) {
-            process.removeListener("exit", leaveAlternateScreen);
-            leaveAlternateScreen();
+        if (!alternateScreen) {
+            process.exit(code);
+            return;
         }
-        process.exit(code);
+        process.removeListener("exit", leaveAlternateScreen);
+        alternateScreen = false;
+        process.stdout.write(LEAVE_ALTERNATE_SCREEN, () => process.exit(code));
     };
     if (!bounded && !eventStream && tty) {
         process.stdout.write(ENTER_ALTERNATE_SCREEN);
@@ -1527,7 +1525,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                     if (bounded)
                         eventLines.push(line);
                 }
-                process.stderr.write("status: keepalive\n");
+                if (decisionEvents.length === 0)
+                    process.stderr.write("status: keepalive\n");
             }
             else {
                 frame = renderFrame(cwd, binaryVersion, nowMs, i, workerLiveness, true, namedRunId);

package/dist/cli/commands/version.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../../package.json");
 const distDir = join(dirname(pkgPath), "dist");
@@ -25,5 +25,5 @@ export function distFingerprint(dir = distDir) {
 }
 export async function version(argv = [], dir = distDir) {
     const { version: v } = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return argv.includes("--dist") ? `${v} dist:${distFingerprint(dir)}` : v;
+    return argv.includes("--dist") ? `${v} dist:${resolve(dir)} fingerprint:${distFingerprint(dir)}` : v;
 }

package/dist/compile/collateral.d.ts

@@ -47,12 +47,21 @@ export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "
  */
 export declare function criterionReadsOnly(text: string, target: string): boolean;
 export declare function newDirectoryLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
+export interface SourceScopeFinding {
+    taskId: string;
+    /** Complete sorted hit set. Rendering may cap it; compile-time enforcement never does. */
+    paths: string[];
+}
+/** Structured OBS-76 findings shared by human rendering and native compile enforcement. */
+export declare function sourceScopeFindings(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string): SourceScopeFinding[];
+/** Human display is derived from the structured finding; no enforcement path parses this text. */
+export declare function renderSourceScopeFinding(finding: SourceScopeFinding): string;
 /**
  * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
  * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
  * Advisory plan output only, same contract as collateralLints.
  */
-export declare function sourceScopeLints(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string): string[];
+export declare function sourceScopeLints(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "acceptance">>, repoRoot: string, findings?: readonly SourceScopeFinding[]): string[];
 /** Max acceptance items per task. Consult-converged (copus/csol/cfable R2). */
 export declare const MAX_ACCEPTANCE_ITEMS = 6;
 /** Max files[] patterns per task. */
@@ -141,15 +150,15 @@ export type ReviewParticipation = TickmarkrConfig["review"] & {
 export declare function reviewParticipationErrors(tasks: ReadonlyArray<Pick<Task, "id" | "files" | "shape">>, review: ReviewParticipation): string[];
 /**
  * Every Task Unit Contract violation in one pass, ready to throw. `repoRoot` backs the
- * symbol-ownership lint and the participation config, and defaults to the invocation directory —
- * correct for the CLI/daemon, which compile from inside the target repo.
+ * symbol-ownership lint and participation overlay, and defaults to the invocation directory for
+ * programmatic compiles. The CLI passes its target repository explicitly.
  *
  * The read declaration (`context:`) rides on this parameter, on the task objects themselves — the
  * aggregator never infers it from the repo, the config, or a sibling task. It is OPTIONAL: a caller
  * whose task objects carry no `context` gets byte-identical verdicts to the ones it got before the
  * field existed, because an absent declaration grants no authority at all.
  *
- * The compile seam in src/compile/index.ts threads `compileSource`'s repo root here, so CLI tests
- * and programmatic compiles check the same repository overlay the later run will use.
+ * The compile seam in src/compile/index.ts threads `compileSource`'s repo root here when supplied;
+ * otherwise this function deliberately checks process.cwd().
  */
 export declare function taskUnitContractErrors(tasks: ReadonlyArray<Pick<Task, "id" | "goal" | "files" | "deps" | "acceptance" | "shape"> & Partial<Pick<Task, "context">>>, repoRoot?: string, review?: ReviewParticipation): string[];

package/dist/compile/collateral.js

@@ -460,23 +460,18 @@ export function newDirectoryLints(tasks, repoRoot) {
     }
     return lines;
 }
-/**
- * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
- * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
- * Advisory plan output only, same contract as collateralLints.
- */
-export function sourceScopeLints(tasks, repoRoot) {
-    const newDirLints = newDirectoryLints(tasks, repoRoot);
+/** Structured OBS-76 findings shared by human rendering and native compile enforcement. */
+export function sourceScopeFindings(tasks, repoRoot) {
     const perTask = tasks
         .map((t) => ({ t, needles: criteriaSymbols(t.acceptance) }))
         .filter((x) => x.needles.length);
     if (!perTask.length)
-        return newDirLints;
+        return [];
     const srcFiles = walkCode(repoRoot, "src");
     if (!srcFiles.length)
-        return newDirLints;
+        return [];
     const read = makeReader(repoRoot);
-    const lines = [];
+    const findings = [];
     for (const { t, needles } of perTask) {
         // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.
         const scoped = filesGlob(t.files.map((f) => f.replace(/^\.\//, "")));
@@ -495,11 +490,23 @@ export function sourceScopeLints(tasks, repoRoot) {
         if (!hits.length)
             continue;
         hits.sort();
-        const listed = hits.slice(0, MAX_HITS_PER_TASK).join(", ");
-        const tail = hits.length > MAX_HITS_PER_TASK ? " (capped)" : "";
-        lines.push(`${t.id}: criteria implicate out-of-scope source not in files[]: ${listed}${tail}`);
+        findings.push({ taskId: t.id, paths: hits });
     }
-    return [...newDirLints, ...lines];
+    return findings;
+}
+/** Human display is derived from the structured finding; no enforcement path parses this text. */
+export function renderSourceScopeFinding(finding) {
+    const listed = finding.paths.slice(0, MAX_HITS_PER_TASK).join(", ");
+    const tail = finding.paths.length > MAX_HITS_PER_TASK ? " (capped)" : "";
+    return `${finding.taskId}: criteria implicate out-of-scope source not in files[]: ${listed}${tail}`;
+}
+/**
+ * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
+ * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
+ * Advisory plan output only, same contract as collateralLints.
+ */
+export function sourceScopeLints(tasks, repoRoot, findings = sourceScopeFindings(tasks, repoRoot)) {
+    return [...newDirectoryLints(tasks, repoRoot), ...findings.map(renderSourceScopeFinding)];
 }
 // ── Task Unit Contract (OBS-212 / OBS-214) ────────────────────────────────────────────────────
 // These are ERRORS, not advisories. Everything above this line is a plan-time warning the author
@@ -835,9 +842,9 @@ export function symbolOwnershipErrors(tasks, repoRoot) {
  * cannot be a warning, because nothing downstream would stop it — the gate would honour the policy.
  */
 export function reviewParticipationErrors(tasks, review) {
-    // The shipped critical paths are a FLOOR, not a default that a config replaces: this lint resolves
-    // its config from a repo root the compile seam cannot always name (see taskUnitContractErrors), and
-    // the one direction that must never happen is a wrong root lowering enforcement below what tickmarkr
+    // The shipped critical paths are a FLOOR, not a default that a config replaces: a programmatic
+    // compile may rely on taskUnitContractErrors' process.cwd() default, and the one direction that
+    // must never happen is a mismatched invocation root lowering enforcement below what tickmarkr
     // ships. Union is monotone — a repo-local list can only add.
     const critical = [...new Set([...DEFAULT_REVIEW_CRITICAL_PATHS, ...(review.criticalPaths ?? [])])];
     const errors = [];
@@ -871,11 +878,10 @@ export function reviewParticipationErrors(tasks, review) {
     return errors;
 }
 /**
- * The ACTIVE participation config for a compile rooted at `repoRoot`. Same default-argument contract
- * as `repoRoot` itself: the CLI and daemon compile from inside the target repo, so the repo's own
- * config (plus the global overlay) is the config the run will gate under. A config the loader cannot
- * read degrades to the shipped defaults rather than crashing the compile — every command that reaches
- * this seam loads the same config itself and reports a malformed one loudly.
+ * The ACTIVE participation config for a compile rooted at `repoRoot`. CLI compilation supplies its
+ * target root; a programmatic caller that omits it uses taskUnitContractErrors' process.cwd() default,
+ * so its active overlay is the invocation repository. Native CLI compiles independently read the
+ * overlay fail-closed at the finalization seam, so malformed YAML is loud.
  */
 function activeReviewParticipation(repoRoot) {
     try {
@@ -888,16 +894,16 @@ function activeReviewParticipation(repoRoot) {
 }
 /**
  * Every Task Unit Contract violation in one pass, ready to throw. `repoRoot` backs the
- * symbol-ownership lint and the participation config, and defaults to the invocation directory —
- * correct for the CLI/daemon, which compile from inside the target repo.
+ * symbol-ownership lint and participation overlay, and defaults to the invocation directory for
+ * programmatic compiles. The CLI passes its target repository explicitly.
  *
  * The read declaration (`context:`) rides on this parameter, on the task objects themselves — the
  * aggregator never infers it from the repo, the config, or a sibling task. It is OPTIONAL: a caller
  * whose task objects carry no `context` gets byte-identical verdicts to the ones it got before the
  * field existed, because an absent declaration grants no authority at all.
  *
- * The compile seam in src/compile/index.ts threads `compileSource`'s repo root here, so CLI tests
- * and programmatic compiles check the same repository overlay the later run will use.
+ * The compile seam in src/compile/index.ts threads `compileSource`'s repo root here when supplied;
+ * otherwise this function deliberately checks process.cwd().
  */
 export function taskUnitContractErrors(tasks, repoRoot = process.cwd(), review = activeReviewParticipation(repoRoot)) {
     return [