tickmarkr 2.3.0 → 2.4.1

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

@@ -1,24 +1,25 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
-import { allAdapters, discoverChannels, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, servableExclusions, servabilityLine } from "../../adapters/registry.js";
+import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
 import { formatModelAuthLine, contextWindowLints, modelLints, preferEntryLints, ttyVisual } from "../../adapters/model-lints.js";
 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";
-import { excludedChannels, exclusionLine } from "../../route/preference.js";
+import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } 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 { 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(/^\.\//, "")));
@@ -153,7 +167,8 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     // readDoctor cache path: staleness line only fires here (probeAll fallback is fresh by construction).
     const cached = readDoctor(cwd);
     const health = cached ?? (await probeAll(adapters));
-    const channels = discoverChannels(cfg, adapters, health);
+    const pools = rolePools(cfg, adapters, health);
+    const channels = pools.worker;
     // VIS-04 trust ramp (VALIDATION 13-01-11): preview:true bypasses the routing.learned:off short-circuit so
     // the static-vs-learned comparison renders even when the daemon's learned routing is off. Cold ⇒ undefined ⇒
     // output byte-identical to today.
@@ -168,13 +183,22 @@ 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");
+    if (judgeDeny?.by === "deny") {
+        lines.push(`REFUSAL OBS-576: judge seat ${cfg.judge.adapter}:${cfg.judge.model} is removed by flat routing.deny (${judgeDeny.entry}) — move worker-only policy to routing.deny.workers`, "");
+    }
+    const entrySeats = routingEntrySeatLines(cfg);
+    if (entrySeats.length)
+        lines.push(...entrySeats, "");
     const derivation = (shape) => {
         const floor = cfg.routing.floors[shape];
         return floor ? `    floor ${floor} ← ${mode.provenance[shape] ?? "config floors"}` : null;
@@ -235,6 +259,22 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     lints.push(...modelLints(cfg, health, adapters, { tty: ttyVisual() })); // health may be pre-v1.5/probeAll-fallback — no-detection branch covers both
     // v1.54 T3: dead-steering sweep — advisory only, renders with the routing lints, never alters routing.
     lints.push(...preferEntryLints(cfg, health, overlayPreferShapes(cwd)));
+    const preferMatches = (entry, pool) => pool.some((c) => entry === c.adapter || entry === `${c.adapter}:${c.model}`);
+    const lintInertPrefer = (surface, entries, poolName, pool) => {
+        for (const entry of entries ?? []) {
+            if (!preferMatches(entry, pool))
+                lints.push(`${surface} '${entry}' resolves to no live channel of ${poolName} pool`);
+        }
+    };
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        lintInertPrefer(`routing.map.${shape}.prefer`, entry.prefer, "worker", pools.worker);
+    }
+    lintInertPrefer("review.prefer", cfg.review.prefer, "review", pools.review);
+    lintInertPrefer("consult.prefer", cfg.consult.prefer, "consult", pools.consult);
+    const reviewProviders = new Set(pools.review.map((c) => modelProvider(c.model, c.vendor)));
+    if (pools.review.length > 0 && reviewProviders.size < 2) {
+        lints.push(`review pool concentration: ${pools.review.length} channel(s), ${reviewProviders.size} provider(s)`);
+    }
     // The guard here was `channels.length && !fleetCanCrossVendorReview(channels)`, so the review lint went
     // SILENT at zero channels — the first-run state, where review.required is set and nothing can route at all.
     // Deleting that clause outright is worse than the silence: it fires "no cross-vendor reviewer pair in fleet"
@@ -245,10 +285,32 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     if (cfg.review.required && channels.length === 0) {
         lints.push("review: review.required is set but no channel can route — the fleet is empty; install or authenticate an adapter");
     }
-    else if (cfg.review.required && !fleetCanCrossVendorReview(channels)) {
+    else if (cfg.review.required && !fleetCanCrossVendorReview(pools.review)) {
         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) ?? [])];
@@ -264,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);
@@ -302,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.d.ts

@@ -21,6 +21,7 @@ export declare const GATE_KEYS: {
     readonly acceptance: "A";
     readonly review: "R";
 };
+export declare const STATUS_HELP = "usage: tickmarkr status [<runId>] [--watch [--events]] [--oneline]\nWith --watch --events, stdout is one JSON document per decision event and stderr carries keepalive lines.\nDo not merge stdout and stderr (for example with 2>&1): doing so corrupts the JSON document stream.";
 export declare const decisionEventsFromJournal: (events: JournalEvent[], runId: string, stateDir?: string) => DecisionEvent[];
 export declare const taskBox: (status: TaskStatus) => string;
 export declare const gateBox: (state: "open" | "pass" | "fail" | "skip", unicode: boolean) => string;

package/dist/cli/commands/status.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import * as os from "node:os";
 import { join } from "node:path";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { DEFAULT_CONFIG, loadConfig } from "../../config/config.js";
@@ -8,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";
@@ -108,6 +109,11 @@ const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇",
 const ASCII_SPINNER = ["|", "/", "-", "\\"];
 const SAVE_TERMINAL_TITLE = "\x1b[22;0t";
 const RESTORE_TERMINAL_TITLE = "\x1b[23;0t";
+const ENTER_ALTERNATE_SCREEN = "\x1b[?1049h";
+const LEAVE_ALTERNATE_SCREEN = "\x1b[?1049l";
+export const STATUS_HELP = `usage: tickmarkr status [<runId>] [--watch [--events]] [--oneline]
+With --watch --events, stdout is one JSON document per decision event and stderr carries keepalive lines.
+Do not merge stdout and stderr (for example with 2>&1): doing so corrupts the JSON document stream.`;
 const decisionEvidence = (stateDir, runId, sequence) => `${stateDir}/runs/${runId}/journal.jsonl#L${sequence}`;
 const DECISION_GATE_VERDICTS = {
     passed: "passed",
@@ -854,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 {
@@ -894,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)
@@ -941,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);
@@ -1085,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 {
@@ -1109,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)
+    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"))
@@ -1127,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
@@ -1324,6 +1322,8 @@ const oneLine = (cwd, namedRunId) => {
     return sanitizeTaskText([record.runId, ...claims].join(" · "));
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
+    if (argv.some((arg) => arg === "--help" || arg === "-h"))
+        return STATUS_HELP;
     const namedRunId = positionalRunId(argv);
     if (argv.includes("--oneline"))
         return oneLine(cwd, namedRunId);
@@ -1419,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)
@@ -1456,6 +1456,13 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     // 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 : armWatchSupervision(cwd, opts.supervisionBeatMs);
+    let alternateScreen = false;
+    const leaveAlternateScreen = () => {
+        if (!alternateScreen)
+            return;
+        alternateScreen = false;
+        process.stdout.write(LEAVE_ALTERNATE_SCREEN);
+    };
     let titleSaved = false;
     const restoreTitle = () => {
         if (!titleSaved)
@@ -1478,6 +1485,34 @@ 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.exit(code);
+            return;
+        }
+        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);
+        alternateScreen = true;
+        process.once("exit", leaveAlternateScreen);
+        for (const [signal, code] of [["SIGINT", 130], ["SIGTERM", 143]]) {
+            const handler = exitFromSignal(code);
+            signalHandlers.push([signal, handler]);
+            process.once(signal, handler);
+        }
+    }
     try {
         for (let i = 0; i < iterations; i++) {
             const nowMs = now();
@@ -1490,6 +1525,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                     if (bounded)
                         eventLines.push(line);
                 }
+                if (decisionEvents.length === 0)
+                    process.stderr.write("status: keepalive\n");
             }
             else {
                 frame = renderFrame(cwd, binaryVersion, nowMs, i, workerLiveness, true, namedRunId);
@@ -1525,6 +1562,12 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             process.removeListener("exit", restoreTitle);
             restoreTitle();
         }
+        for (const [signal, handler] of signalHandlers)
+            process.removeListener(signal, handler);
+        if (alternateScreen) {
+            process.removeListener("exit", leaveAlternateScreen);
+            leaveAlternateScreen();
+        }
     }
     return bounded ? eventStream ? eventLines.join("\n") : frames.join(sep) : "";
 }

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

@@ -9,6 +9,7 @@ export declare function verifyStateRoot(cwd: string): Promise<string>;
 /** Cache identity is repository content, never a checkout path. */
 export declare function baselineCachePath(cwd: string, baseSha: string, commands: Record<string, string>): string;
 export declare function excludeAuthorProvider(channels: BillingChannel[], author: BillingChannel): BillingChannel[];
+export declare const VERIFY_HELP = "usage: tickmarkr verify [--base <ref>] [--criteria <file> | --task <id>] [--json]\nThe final verdict and JSON result are written to stdout; progress and diagnostics are written to stderr.\nDo not merge stdout and stderr (for example with 2>&1): doing so corrupts the verdict stream.";
 export declare function verify(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;

package/dist/cli/commands/verify.js

@@ -125,7 +125,12 @@ async function warnWideTaskRange(cwd, stateRoot, taskId, mergeBase) {
         console.error(`verify: WARNING --task ${taskId} range also carries merge commit(s) for ${others.map((row) => `${row.taskId} ${row.commit.slice(0, 12)}`).join(", ")}; ${taskId}'s own merge ${own.commit} is the intended HEAD`);
     }
 }
+export const VERIFY_HELP = `usage: tickmarkr verify [--base <ref>] [--criteria <file> | --task <id>] [--json]
+The final verdict and JSON result are written to stdout; progress and diagnostics are written to stderr.
+Do not merge stdout and stderr (for example with 2>&1): doing so corrupts the verdict stream.`;
 export async function verify(argv, cwd = process.cwd()) {
+    if (argv.some((arg) => arg === "--help" || arg === "-h"))
+        return { out: VERIFY_HELP, code: 0 };
     const { values } = parseArgs({
         args: argv,
         options: {

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/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)\n  status        live run state\n  stats         all-run channel delivery, red, rescue, author and reviewer statistics\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  beat <tier>   record one supervision beat for orchestrator|orchestrator-context|overseer|overseer-context|watch, --seat <identity> required (--stand-down to hand off); a supervising seat's own watcher loop calls it, and status reads the tier STALE once the beats stop\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)\n  status        live run state (--watch --events: JSON documents on stdout, keepalives on stderr; 2>&1 corrupts the stream)\n  stats         all-run channel delivery, red, rescue, author and reviewer statistics\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 verdict/JSON on stdout, progress on stderr; 2>&1 corrupts the verdict stream (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  beat <tier>   record one supervision beat for orchestrator|orchestrator-context|overseer|overseer-context|watch, --seat <identity> required (--stand-down to hand off); a supervising seat's own watcher loop calls it, and status reads the tier STALE once the beats stop\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -37,9 +37,9 @@ usage: tickmarkr <command>
   plan          dry-run routing table + cost estimate + floor lints
   eval          run checked-in fixtures against every channel in isolated temp repos
   run           execute the graph (--concurrency N --driver auto|herdr|subprocess|orca --route-strict; orca runs only when named)
-  status        live run state
+  status        live run state (--watch --events: JSON documents on stdout, keepalives on stderr; 2>&1 corrupts the stream)
   stats         all-run channel delivery, red, rescue, author and reviewer statistics
-  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD — no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])
+  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD — verdict/JSON on stdout, progress on stderr; 2>&1 corrupts the verdict stream (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])
   resume <id>   continue a run from its journal
   report <id>   cost/quality report (--md for committable execution record)
   profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)

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,22 +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.
  *
- * KNOWN GAP (R2 review, T6/T7 scope): the compile seam in src/compile/index.ts
- * (`enforceTaskUnitContract`) does not thread `compileSource`'s `root` argument into this call, so a
- * PROGRAMMATIC compile whose target repo differs from process.cwd() resolves the wrong root and can
- * miss that repo's own `review.criticalPaths`. Threading it is one line in src/compile/index.ts,
- * outside this task's file scope. Two things bound the exposure meanwhile, both live: the critical
- * set here is the UNION with the shipped defaults, so a wrong root can never lower enforcement below
- * the shipped floor; and the review GATE — which is handed the run's real config — refuses to skip a
- * critical path itself (src/gates/review.ts), so a lint this seam misses costs a late verdict rather
- * than an unreviewed one. The compile lint is the early warning; the gate is the fail-closed backstop.
+ * 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[];