tickmarkr 2.6.1 → 2.6.3

package/dist/cli/commands/plan.js

@@ -11,9 +11,9 @@ import { batteryPriority, chainDepth, dispatchWaves, graphDefinitionHash, loadGr
 import { filesGlob } from "../../graph/files-glob.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { pendingDaemonApprovalActions, resolveRunMode } from "../../run/daemon.js";
-import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
+import { disallowedBy, excludedChannels, exclusionLine, observedSeat, routingEntrySeatLines } from "../../route/preference.js";
 import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.js";
-import { route, RoutingError } from "../../route/router.js";
+import { resolvedFloor, route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
 import { Journal, loadRoutingProfile, readProfileCursor, recordedGraphDefinitionHash, RUNS_WINDOW } from "../../run/journal.js";
@@ -237,16 +237,21 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         ...(runLine ? [runLine] : []),
         "",
     ];
-    const judgeDeny = disallowedBy(cfg.judge, cfg.routing, "judge");
+    // OBS-1186: the judge seat is judged under doctor's cached identity for that exact channel — the
+    // runtime judge's rule; unknown stays conservative (alias-family deny).
+    const judgeDeny = disallowedBy(observedSeat(health, cfg.judge.adapter, cfg.judge.model), 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;
+    // OBS-1185: the floor route() resolved for THIS task — a task hint over the configured/mode floor.
+    const derivation = (t) => {
+        const floor = resolvedFloor(t, cfg);
+        if (!floor)
+            return null;
+        return `    floor ${floor.tier} ← ${floor.source === "task" ? "task hint" : mode.provenance[t.shape] ?? "config floors"}`;
     };
     const excluded = excludedChannels(cfg, adapters, health);
     if (excluded.length)
@@ -408,7 +413,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             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)}` : ""}`, chainLine(t));
-            const d = derivation(t.shape);
+            const d = derivation(t);
             if (d)
                 lines.push(d);
             if (r.deviation) {
@@ -432,7 +437,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
                 throw e;
             const msg = `${e.message}${exclusionReason(e.message)}`;
             lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} !! ${msg}`, chainLine(t));
-            const d = derivation(t.shape);
+            const d = derivation(t);
             if (d)
                 lines.push(d);
             lints.push(`${t.id}: unroutable — ${msg}`);

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

@@ -1,4 +1,5 @@
+import type { BaselineCommand } from "../../gates/baseline.js";
 import { type ChannelCost } from "../../report/cost.js";
 import { type JournalEvent, type TelemetryRow } from "../../run/journal.js";
-export declare function renderMarkdownRecord(runId: string, events: JournalEvent[], prices?: ChannelCost[], rows?: TelemetryRow[]): string;
+export declare function renderMarkdownRecord(runId: string, events: JournalEvent[], prices?: ChannelCost[], rows?: TelemetryRow[], suite?: BaselineCommand): string;
 export declare function report(argv: string[], cwd?: string): Promise<string>;

package/dist/cli/commands/report.js

@@ -1,4 +1,5 @@
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { ttyVisual } from "../../adapters/model-lints.js";
 import { addUsage } from "../../adapters/types.js";
@@ -11,7 +12,8 @@ import { estimateCosts } from "../../report/cost.js";
 import { assignmentChannel, buildOperatorRecord, formatChannelMoney, formatChannelTokens, formatTokenUsage as fields, totalTokens as total, } from "../../report/operator-record.js";
 import { cellsOf, cellSummary } from "../../route/profile.js";
 import { Journal, loadRoutingProfile } from "../../run/journal.js";
-import { formatTipProof, runEndTipProof } from "../../run/daemon.js";
+import { baselineProvenanceOf, fingerprintsOf, forgivenFingerprints, forgivenGateRow, formatBaselineProvenance, formatFingerprints, formatForgiven, formatTipProof, runEndTipProof, } from "../../run/daemon.js";
+import { formatSpan, WALL_PRIORITY_TEXT, wallBudget, wallBudgetFacts } from "../../run/wall-budget.js";
 import { deriveRunCockpitData } from "../../tui/cockpit/derive.js";
 const n = (x) => x.toLocaleString("en-US"); // explicit locale — CI/darwin flake guard
 const EM = "—";
@@ -75,6 +77,44 @@ const wallClock = (start, end) => {
     const minutes = Math.floor(seconds / 60);
     return minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
 };
+// OBS-1201: the disjoint wall budget, or why the journal cannot give one — never a zeroed table.
+const wallFacts = (events) => {
+    const budget = wallBudget(events);
+    if (!budget)
+        return [["window", "not measurable — the journal names no run-start with a readable timestamp"]];
+    return [["window", `${formatSpan(budget.wallMs)} — each instant counted once, by priority ${WALL_PRIORITY_TEXT}; task-time sums concurrent spans`], ...wallBudgetFacts(budget)];
+};
+// OBS-634: the four numbers the baseline capture already measured for the test command. A capture that
+// measured nothing says so; a missing number is not measurable, never a zero.
+const suiteTelemetry = (entry) => {
+    if (!entry)
+        return "not recorded — this run's baseline holds no test capture";
+    if (entry.infra)
+        return `not measurable — the baseline capture returned no verdict (${entry.invalidCause ?? "infra"})`;
+    if (typeof entry.durationMs !== "number" || !Number.isFinite(entry.durationMs))
+        return "not recorded — the baseline predates capture timing";
+    const unmeasured = "not measurable (the runner named no per-file durations)";
+    const sum = entry.fileDurationSumMs;
+    const parallelism = entry.impliedParallelism;
+    const longest = entry.longestFile;
+    return [
+        `wall ${formatSpan(entry.durationMs)}`,
+        `file-sum ${typeof sum === "number" ? formatSpan(sum) : unmeasured}`,
+        `implied parallelism ${typeof parallelism === "number" ? parallelism.toFixed(2) : unmeasured}`,
+        `longest file ${longest ? `${longest.file} ${formatSpan(longest.durationMs)}` : unmeasured}`,
+        ...(typeof entry.fileCount === "number" ? [`${entry.fileCount} files`] : []),
+    ].join(" · ");
+};
+/** The run's own baseline.json test entry; absent or unreadable reads as not recorded. */
+const baselineTestEntry = (runDir) => {
+    try {
+        const baseline = JSON.parse(readFileSync(join(runDir, "baseline.json"), "utf8"));
+        return baseline.commands?.test;
+    }
+    catch {
+        return undefined;
+    }
+};
 const detail = (value) => typeof value === "string" || typeof value === "number" ? String(value) : EM;
 // T11: a gate that declined never ran. Drop those before the comparison metrics so the pass rate
 // counts only gates that actually ran — a declined gate is never a pass and never pads the base.
@@ -170,6 +210,10 @@ const VERIFICATION_READING = {
     failed: "FAILED — the run did not verify its own tip",
     absent: "absent — no tip verification recorded: neither passed nor failed",
 };
+function forgivenLines(events) {
+    const forgiven = forgivenFingerprints(closedCycle(events));
+    return forgiven.length ? ["- **forgiven vs baseline:**", ...forgiven.map((f) => `  - ${formatForgiven(f)}`)] : [];
+}
 function verificationReading(runId, events) {
     const state = verificationOf(runId, events);
     const proof = runEndTipProof(closedCycle(events));
@@ -179,8 +223,18 @@ function verificationReading(runId, events) {
     }
     return VERIFICATION_READING[state];
 }
+// OBS-1123: a battery row that carried baseline reds names them apart from any red it introduced, so a
+// new regression can never read as forgiven. Rows without the structured fields render as before.
+const fingerprintClauses = (data) => {
+    const fresh = fingerprintsOf(data.freshFingerprints) ?? [];
+    const forgiven = fingerprintsOf(data.forgivenFingerprints);
+    if (!forgiven && !forgivenGateRow(data))
+        return "";
+    return `${fresh.length ? `; new red (not in baseline): ${formatFingerprints(fresh)}` : ""}`
+        + `; forgiven vs baseline: ${formatFingerprints(forgiven)} — ${formatBaselineProvenance(baselineProvenanceOf(data.baselineProvenance))}`;
+};
 // VIS-07 / REC-01: derived only from the run journal, telemetry, and local configuration.
-export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
+export function renderMarkdownRecord(runId, events, prices = [], rows = [], suite) {
     const runStart = events.find((e) => e.event === "run-start");
     const runEnd = [...events].reverse().find((e) => e.event === "run-end");
     const baseRef = typeof runStart?.data.baseRef === "string" ? runStart.data.baseRef : EM;
@@ -216,6 +270,8 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         `- **failed:** ${count("failed")}`,
         `- **human:** ${count("human")}`,
         `- **verification:** ${verificationReading(runId, events)}`,
+        // OBS-1123: the same fold the run-end record states, over the same closed cycle as verification.
+        ...forgivenLines(events),
         "",
         "## Usage & efficiency",
         "",
@@ -226,6 +282,11 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         `- **consults:** ${events.filter((e) => e.event === "consult-verdict").length}`,
         `- **escalations:** ${events.filter((e) => e.event === "escalation").length}`,
         "",
+        "## Wall budget",
+        "",
+        ...wallFacts(events).map(([label, fact]) => `- **${label}:** ${fact}`),
+        `- **suite telemetry (baseline test capture):** ${suiteTelemetry(suite)}`,
+        "",
     ];
     lines.push("## Channels", "");
     const operatorRecords = buildOperatorRecord(events, prices);
@@ -280,7 +341,7 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
                 }
                 const resolved = gate === "review" && g.data.pass === true && Array.isArray(g.data.resolved)
                     ? g.data.resolved.filter((id) => typeof id === "string") : [];
-                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}${resolved.length ? `; resolved: ${resolved.join(", ")}` : ""}`);
+                lines.push(`  - ${gate}: ${pass} — ${firstLine(g.data.details)}${resolved.length ? `; resolved: ${resolved.join(", ")}` : ""}${fingerprintClauses(g.data)}`);
             }
             for (const row of leg2) {
                 const pass = row.data.pass === true ? "pass" : row.data.pass === false ? "fail" : EM;
@@ -310,7 +371,7 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
     }
     return lines.join("\n").trimEnd() + "\n";
 }
-function textReport(runId, events, rows, cwd) {
+function textReport(runId, events, rows, cwd, suite) {
     // one group per adapter:model, carrying channel + the folded usage across its rows
     const groups = new Map();
     for (const r of rows) {
@@ -372,6 +433,10 @@ function textReport(runId, events, rows, cwd) {
         `tickmark rate: ${gateRan ? Math.round((100 * gatePass) / gateRan) : 0}% (${gatePass}/${gateRan})${declinedCount ? ` · declined: ${declinedCount}` : ""}`,
         `escalations: ${escalations} · National Office consults: ${consults} · quota failovers: ${failovers}`,
         "",
+        "wall budget — exposed wall, disjoint:",
+        ...wallFacts(events).map(([label, fact]) => `  ${label.padEnd(14)} ${fact}`),
+        `  ${"suite".padEnd(14)} ${suiteTelemetry(suite)}`,
+        "",
         "spend — tokens (measured where observed):",
         ...tokenLines,
         "spend — money:",
@@ -391,7 +456,7 @@ const stylizeReport = (out) => {
         return out;
     return out
         .replace(/^.*$/m, (first) => `${title(first)}\n${rule()}`) // non-global /m ⇒ first line only
-        .replace(/^(engagement summary — audit trail:|spend — tokens[^\n]*|spend — money:|learning \([^\n]*)$/gm, (l) => dim(l));
+        .replace(/^(engagement summary — audit trail:|wall budget — [^\n]*|spend — tokens[^\n]*|spend — money:|learning \([^\n]*)$/gm, (l) => dim(l));
 };
 export async function report(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
@@ -412,6 +477,7 @@ export async function report(argv, cwd = process.cwd()) {
     const events = j.read();
     const rows = j.readTelemetry();
     const cfg = loadConfig(cwd);
+    const suite = baselineTestEntry(j.dir);
     let bundleNote = "";
     if (values.bundle) {
         // Local-only write of the pure proof packet — no network path exists in buildProofBundle.
@@ -438,7 +504,7 @@ export async function report(argv, cwd = process.cwd()) {
         comparison = "\n" + outcome.text;
     }
     if (values.md) {
-        return bundleNote + renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows) + comparison;
+        return bundleNote + renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows, suite) + comparison;
     }
-    return bundleNote + stylizeReport(textReport(runId, events, rows, cwd)) + comparison;
+    return bundleNote + stylizeReport(textReport(runId, events, rows, cwd, suite)) + comparison;
 }

package/dist/cli/commands/resume.js

@@ -1,4 +1,5 @@
 import { parseArgs } from "node:util";
+import { readDoctor } from "../../adapters/registry.js";
 import { loadConfig } from "../../config/config.js";
 import { classifyHost, parseDriverOverride, pickDriver, preflightHostDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
@@ -31,9 +32,10 @@ export async function resume(argv, cwd = process.cwd()) {
     // v1.87 T3 (OBS-162, twice-carried workaround): the preflight runs AFTER the graph is read and
     // sees only the shapes the resumed graph carries. A deny∩prefer collision on a shape no resumed
     // task uses is a config fact the run would never resolve — it must not refuse the only
-    // crash-recovery path. doctor still walks the whole map.
+    // crash-recovery path. doctor still walks the whole map. OBS-1143: aliases are judged by the
+    // identity doctor cached — the same one the daemon's discovery routes with.
     const graph = loadGraph(cwd);
-    const collisions = denyPreferCollisions(cfg, graph.tasks.map((t) => t.shape));
+    const collisions = denyPreferCollisions(cfg, graph.tasks.map((t) => t.shape), readDoctor(cwd));
     if (collisions.length) {
         throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
     }

package/dist/cli/commands/status.js

@@ -12,11 +12,12 @@ import { authorsNote, doneAuthors } from "../../run/operator-state.js";
 import { projectOperatorSummary } from "../../run/operator-summary.js";
 import { trackJournalRows } from "../../run/protocol.js";
 import { newestPark, permittedDecisionVerbs } from "./approve.js";
-import { Journal, formatJournalNarration, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.js";
+import { Journal, bindingToken, effectiveEvents, formatJournalNarration, parseJournalText, physicalLine, engagementComparable, isQualityFailureParkKind, parseRunId, preservedRefsByTask, recordedTaskFailureKind, runHasEnded, upheldFeedbackByTask, } from "../../run/journal.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";
+import { formatSpan, wallBudget, wallBudgetFacts } from "../../run/wall-budget.js";
 import { armWatchSupervision, observeNamedRun, WATCH_OWNER_ENV, readSupervision, supervisionText } from "../../run/supervision.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
 import { cellWidth, fitCells, wrapCells } from "../../tui/cockpit/width.js";
@@ -167,7 +168,7 @@ export const decisionEventsFromJournal = (events, runId, stateDir = ".tickmarkr"
                 ...base,
                 type: "human-decision-required",
                 tier: "decision",
-                approvalCommand: `tickmarkr approve ${runId} ${event.taskId}`,
+                approvalCommand: `tickmarkr approve ${runId} ${event.taskId} --park ${bindingToken({ line: physicalLine(events, index), ts: event.ts })}`,
                 ...(typeof event.data.kind === "string" ? { kind: event.data.kind } : {}),
                 ...(typeof event.data.reason === "string" ? { reason: event.data.reason } : {}),
             }];
@@ -841,18 +842,6 @@ const statusEngagement = (events, loadedHash) => {
     }
     return { comparable: true };
 };
-// The journal's own reader rule (src/run/journal.ts readJsonl), applied to bytes already in hand:
-// skip blanks, drop a line that will not parse (a torn trailing write after a crash), keep the rest.
-const parseJournalSnapshot = (raw) => raw.split("\n").flatMap((line) => {
-    if (!line.trim())
-        return [];
-    try {
-        return [JSON.parse(line)];
-    }
-    catch {
-        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.
@@ -892,7 +881,7 @@ const readRunRecord = (cwd, graph, namedRunId) => {
     if (!runId)
         return undefined;
     const raw = readRunJournalRaw(cwd, runId, lockedRunId === runId);
-    const events = parseJournalSnapshot(raw);
+    const events = parseJournalText(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.
     const engagement = statusEngagement(events, graphDefinitionHash(graph));
@@ -918,7 +907,8 @@ const recordTaskRows = (record, graph, isDaemonAlive) => record.comparable && re
 const recordProjection = (record, graph, isDaemonAlive) => {
     const rows = record ? recordTaskRows(record, graph, isDaemonAlive) : new Map();
     const events = record?.comparable ? record.events : [];
-    const activity = projectActivity(record?.runId ?? "", trackJournalRows(record?.runId ?? "", events.map((raw, sourceIndex) => ({ raw, sourceIndex }))), graph.tasks);
+    // OBS-1178: a refused or unsound decision released nothing, so the activity fold never reads it.
+    const activity = projectActivity(record?.runId ?? "", trackJournalRows(record?.runId ?? "", effectiveEvents(events).map((raw, sourceIndex) => ({ raw, sourceIndex }))), graph.tasks);
     const tasks = graph.tasks.map(task => {
         const row = rows.get(task.id);
         const evidence = events.filter(event => event.taskId === task.id);
@@ -1068,12 +1058,28 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     // OBS-738: recovery facts stay on the journal's two established reducers. The prefix fold keeps an
     // older journal equally readable by asking upheldFeedbackByTask what was active at that exact
     // restore boundary; current resume-restore rows additionally carry the same task for narration.
+    // OBS-1178: both folds read decisions through the one decision fold over the whole journal.
+    const decided = effectiveEvents(events);
     const preservedRefs = preservedRefsByTask(events);
-    const restoredUpheldFeedback = new Set(events.flatMap((event, index) => event.event === "resume-restore" && event.taskId
-        && upheldFeedbackByTask(events.slice(0, index)).has(event.taskId)
+    const restoredUpheldFeedback = new Set(decided.flatMap((event, index) => event.event === "resume-restore" && event.taskId
+        && upheldFeedbackByTask(decided.slice(0, index)).has(event.taskId)
         ? [event.taskId]
         : []));
+    // OBS-1178: a failed task's newest task-failed row is the token its recheck binds to. Only an
+    // effective decision consumes it — a refused or unsound recheck leaves the task failed and the token shown.
+    const failureTokens = new Map();
+    decided.forEach((event, index) => {
+        if (!event.taskId || !["task-dispatch", "task-done", "task-failed", "task-human", "task-approved"].includes(event.event))
+            return;
+        if (event.event === "task-failed")
+            failureTokens.set(event.taskId, bindingToken({ line: physicalLine(decided, index), ts: event.ts }));
+        else
+            failureTokens.delete(event.taskId);
+    });
     const recoveryLinesForTask = (taskId) => [
+        ...(failureTokens.has(taskId) && runId
+            ? [`failed — ${taskId} — failure ${failureTokens.get(taskId)} — re-gate landed work with \`tickmarkr approve ${runId} ${taskId} --recheck --park ${failureTokens.get(taskId)}\``]
+            : []),
         ...(preservedRefs.get(taskId) ?? []).flatMap(({ ref, diffCommand }) => [
             `preserved worktree — ${taskId} — ${ref}`,
             `  ${diffCommand}`,
@@ -1150,6 +1156,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             ...(hotPhase ? { hotPhase } : {}),
             ...(runId ? { runId } : {}),
             workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
+            events,
         };
     }
     // TTY: the operator-approved task table. The daemon gives this surface a ~110-column pane first;
@@ -1359,8 +1366,22 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         ...(hotPhase ? { hotPhase } : {}),
         ...(runId ? { runId } : {}),
         workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
+        events,
     };
 };
+// OBS-1201: the one-shot print closes with where the run's wall went (src/run/wall-budget.ts). A
+// window of zero length measured nothing, so it prints nothing; watch frames are untouched. Rows wrap
+// to the board width, so narrowing costs rows, never columns.
+const wallBudgetLines = (events) => {
+    const budget = wallBudget(events);
+    if (!budget || budget.wallMs <= 0)
+        return [];
+    const columns = Math.max(40, process.stdout.columns ?? 120);
+    return [
+        `  wall budget ${formatSpan(budget.wallMs)} · each instant once, by priority`,
+        ...wallBudgetFacts(budget).map(([label, fact]) => `    ${label} ${fact}`),
+    ].flatMap((line) => wrapCells(line, columns, { continuationPrefix: "      " }));
+};
 /**
  * The compact form a statusline calls, so journal interpretation happens ONCE, inside the product.
  * (An operator-local bash reimplementation counted `tip-verify` events instead of reading the
@@ -1396,7 +1417,9 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     // The task-table frame owns its own two-row brand lockup; the four-row global banner would
     // create the second header the approved replacement removes.
     if (!argv.includes("--watch")) {
-        return renderFrame(cwd, binaryVersion, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId).content;
+        const frame = renderFrame(cwd, binaryVersion, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId);
+        const wall = wallBudgetLines(frame.events);
+        return wall.length ? [frame.content, "", ...wall].join("\n") : frame.content;
     }
     const eventStream = argv.some((arg) => arg === "--events" || arg === "--jsonl" || arg === "--decision-events");
     const webhookUrl = opts.webhookUrl
@@ -1501,7 +1524,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             decisionRunId = runId;
             journalCursor = 0;
         }
-        const journalEvents = parseJournalSnapshot(readRunJournalRaw(cwd, runId, lockedRunId === runId));
+        const journalEvents = parseJournalText(readRunJournalRaw(cwd, runId, lockedRunId === runId));
         if (journalEvents.length < journalCursor)
             journalCursor = 0;
         const fresh = decisionEventsFromJournal(journalEvents, runId, stateDirName(cwd))

package/dist/cli/help.d.ts

@@ -163,6 +163,8 @@ export declare const COMMAND_HELP: {
         usage: string;
         description: string;
         options: {
+            "--park <line>@<ts>": string;
+            "--gate <gate>": string;
             "--files <glob,\u2026>": string;
             "--by <name>": string;
             "--reason <text>": string;

package/dist/cli/help.js

@@ -131,14 +131,21 @@ export const COMMAND_HELP = {
     approve: {
         usage: "approve <run-id> <task-id> [options]", description: "Append a validated park decision. A running owner may enact it; a closed run requires a separate resume. Decisions cannot be undone.",
         options: {
+            "--park <line>@<ts>": "Bind the decision to the park token status prints (a failed task's recheck binds its failure token); refused once a newer park opens.",
+            "--gate <gate>": "Bind a waive to the park's failed gate; refused when the park failed another gate.",
             "--files <glob,…>": "Extend files[] for a scope-request park with comma-separated repository-relative globs; required for scope approval.",
             "--by <name>": "Name the actor (default: current OS user).",
             "--reason <text>": "Record the decision reason.",
             "--waive": "Waive only the identified failed gate.",
             "--uphold": "Uphold a review failure and fund a fixed attempt.",
             "--recheck": "Request rechecking an infra or failed-gate park; satisfies no gate.",
-            "--review-rounds <N>": "Set a positive integer review-round ceiling with the decision.",
-        }, examples: ["approve run-example T1 --by operator --reason 'ready to proceed'", "approve run-example T1 --recheck --reason 'infra recovered'"],
+            "--review-rounds <N>": "Set a positive integer review-round ceiling that binds only this approval engagement; a later approval without --review-rounds restores the built-in default.",
+        }, examples: [
+            "approve run-example T1 --park 42@2026-09-26T08:00:00.000Z --by operator --reason 'ready to proceed'",
+            "approve run-example T1 --waive --park 42@2026-09-26T08:00:00.000Z --gate review",
+            "approve run-example T1 --recheck --park 42@2026-09-26T08:00:00.000Z --reason 'infra recovered'",
+            "approve run-example T3 --recheck --park 57@2026-09-26T08:05:00.000Z --reason 'failed task: re-gate its landed commits'",
+        ],
     },
     beat: {
         usage: "beat <orchestrator|orchestrator-context|overseer|overseer-context|watch> --seat <identity> [options]",

package/dist/compile/native.js

@@ -911,6 +911,13 @@ acceptance is required on every task (a nested list of observable outcomes).
     - Enumerating one axis exhaustively is what hides the others. A spec that guards PARTIAL coverage
       site-by-site, member-by-member, can be defeated wholesale by CONDITIONAL coverage, which leaves
       every enumeration satisfied. After you enumerate, ask what a single flag would do to the whole set.
+    - A GOAL STATING AN INVARIANT OVER "every", "never" OR "any" CARRIES ITS CLOSED CASE TABLE AS A
+      CRITERION: the in-scope consumers, bridges, operations and event sequences it ranges over, each a
+      row a test exercises. An unenumerated invariant is repaired one edge per review round while every
+      round re-judges the accumulated diff (OBS-1019 add.2). The table binds author and reviewer, never a
+      worker's claim: each review material binds its declared class to the goal clause or criterion it
+      violates through input-to-consequence evidence marked executed, static or blocked. A worker's own
+      table alone never silences a real finding, and blocked evidence is never a pass.
     - EVERY CRITERION NAMES THE PAIR IT DISCRIMINATES: the correct case that MUST PASS, and the
       neighbouring plausible-wrong or false-clean case that MUST FAIL. Two easy examples that both pass are
       not discrimination — they are two ways of being green, and the wrong half is the whole point: it is

package/dist/config/config.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type Effort } from "../graph/schema.js";
 declare const TierEnum: z.ZodEnum<{
     cheap: "cheap";
     mid: "mid";
@@ -41,6 +42,7 @@ export declare const MapEntrySchema: z.ZodObject<{
     escalate: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type MapEntry = z.infer<typeof MapEntrySchema>;
+export declare const EFFORT_ADAPTERS: readonly ["claude-code", "codex"];
 export declare const TierEntrySchema: z.ZodObject<{
     vendor: z.ZodNullable<z.ZodString>;
     channel: z.ZodEnum<{
@@ -58,6 +60,11 @@ export declare const TierEntrySchema: z.ZodObject<{
             sub: "sub";
             api: "api";
         }>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
     }, z.core.$strip>>>;
     windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strip>;
@@ -174,13 +181,13 @@ export declare function effectiveReviewPolicy(files: ReadonlyArray<string>, revi
 export declare function criticalPathHits(files: ReadonlyArray<string>, criticalPaths?: ReadonlyArray<string>): string[];
 export declare const ExecutionPolicySchema: z.ZodObject<{
     boundedInfrastructure: z.ZodDefault<z.ZodBoolean>;
-    repairSelection: z.ZodDefault<z.ZodBoolean>;
+    repairSelection: z.ZodOptional<z.ZodBoolean>;
     taskExecutionLimitMs: z.ZodNumber;
 }, z.core.$strict>;
 export declare const TickmarkrConfigSchema: z.ZodObject<{
     executionPolicy: z.ZodOptional<z.ZodObject<{
         boundedInfrastructure: z.ZodDefault<z.ZodBoolean>;
-        repairSelection: z.ZodDefault<z.ZodBoolean>;
+        repairSelection: z.ZodOptional<z.ZodBoolean>;
         taskExecutionLimitMs: z.ZodNumber;
     }, z.core.$strict>>;
     concurrency: z.ZodNumber;
@@ -274,6 +281,11 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
                 sub: "sub";
                 api: "api";
             }>>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
         }, z.core.$strip>>>;
         windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strip>>;
@@ -297,6 +309,8 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
         tipTest: z.ZodOptional<z.ZodString>;
         lint: z.ZodOptional<z.ZodString>;
         diffCap: z.ZodOptional<z.ZodNumber>;
+        evidenceQuotaBytes: z.ZodOptional<z.ZodNumber>;
+        repairSelection: z.ZodOptional<z.ZodBoolean>;
         byShape: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
             plan: "plan";
             spec: "spec";
@@ -362,6 +376,7 @@ export type TickmarkrConfig = z.infer<typeof TickmarkrConfigSchema>;
 export declare class ConfigError extends Error {
     constructor(message: string);
 }
+export declare const DEFAULT_EVIDENCE_QUOTA_BYTES: number;
 export declare const DEFAULT_CONFIG: TickmarkrConfig;
 export declare function globalConfigDir(): string;
 export declare function overlayPreferShapes(repoRoot: string, opts?: {
@@ -383,6 +398,22 @@ export declare function loadConfigWithMode(repoRoot: string, opts?: {
     cfg: TickmarkrConfig;
     mode: ModeResolution;
 };
+/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the repo overlay resolve them. */
+export type LowerLayerModelOverrides = Record<string, Record<string, Record<string, unknown>>>;
+/** OBS-1182: tiers.<adapter>.modelOverrides as the layers under the repo overlay (defaults + global)
+ *  merge them. Read raw, never schema-validated: a lower layer may only validate beside repo fields
+ *  (global `vendor: null` completed by a repo vendor) and its override metadata is still inherited.
+ *  OBS-1188: an unparseable global file, or a non-map where this path expects a map, is an error —
+ *  never an empty lower layer, which would silently drop the metadata a write must re-mask. */
+export declare function lowerLayerModelOverrides(opts?: {
+    globalDir?: string;
+}): {
+    ok: true;
+    overrides: LowerLayerModelOverrides;
+} | {
+    ok: false;
+    error: string;
+};
 export declare function loadConfig(repoRoot: string, opts?: {
     globalDir?: string;
 }): TickmarkrConfig;
@@ -416,6 +447,8 @@ export type FleetEditable = Partial<Record<DenyScopeKey, string[]>> & {
     denyModels: string[];
     allowOut?: string[];
     tiers: Record<string, Record<string, FleetTierAssignment | null>>;
+    /** OBS-1182: tiers.<adapter>.modelOverrides.<model>.effort — absent = CLI default; present only when one is set */
+    efforts?: Record<string, Record<string, Effort>>;
     map: Record<string, MapEntry>;
     floors: Record<string, Tier>;
 };