tickmarkr 2.6.2 → 2.6.4

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,42 @@
+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;
+import { type JournalEvent, type OwedFold, type TelemetryRow } from "../../run/journal.js";
+export interface FirstPass {
+    passed: number;
+    known: number;
+    unknown: number;
+}
+/**
+ * End-to-end first pass over the finished tasks of the SELECTED journal (no cross-run scan). A task
+ * closed done, merged, or named done by the newest run-end passes only as one dispatch at attempt 0
+ * straight to its merge. A task whose predecessor or dispatch evidence is missing — no run-start, a run
+ * that supersedes another, no dispatch, a first dispatch not at attempt 0 or not recording lifetime
+ * worker dispatch ordinal 0 — is unknown whatever else it shows: attempts reset at every release, so
+ * only the lifetime ordinal proves no earlier dispatch is missing. Otherwise any park, approval, failure, repair, restore or second dispatch is a known miss — a
+ * run-end summary's park or a restart before its merge included — and a would-be pass with no merge is
+ * unknown, never counted as a pass.
+ */
+export declare function endToEndFirstPass(events: readonly JournalEvent[]): FirstPass;
+export declare const firstPassText: ({ passed, known, unknown }: FirstPass) => string;
+/** The CURRENT owed-check fold. `cwd` is any checkout of the run's repository. */
+export declare const currentOwed: (events: readonly JournalEvent[], cwd?: string) => OwedFold;
+export declare const outstandingText: (fold: OwedFold) => string;
+export declare const needsYouText: (events: readonly JournalEvent[], owed: OwedFold) => string;
+/** The wall window alone, for the one-line form: the same partition, never task-time. */
+export declare const wallText: (events: readonly JournalEvent[]) => string;
+/**
+ * The three lead lines. `finished` is the surface's own done tally and tip reading (plus any
+ * comparability or supersession note); the rest is folded here from the journal and the current fold.
+ */
+export declare function leadLines(events: readonly JournalEvent[], owed: OwedFold, finished: {
+    tally: string;
+    tip: string;
+    notes?: string[];
+}): [string, string, string];
+/**
+ * The lead at `columns`: the first row of finished, time and needs you are the first three physical
+ * lines, and every continuation follows them, naming the lead it continues.
+ */
+export declare const leadRows: (lead: readonly string[], columns: number) => string[];
+export declare function renderMarkdownRecord(runId: string, events: JournalEvent[], prices?: ChannelCost[], rows?: TelemetryRow[], suite?: BaselineCommand, cwd?: string): 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";
@@ -10,9 +11,11 @@ import { compareRuns } from "../../report/compare.js";
 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 { effectiveEvents, foldOwedChecks, Journal, loadRoutingProfile, OWED_DISCHARGE_EVENT, } from "../../run/journal.js";
 import { baselineProvenanceOf, fingerprintsOf, forgivenFingerprints, forgivenGateRow, formatBaselineProvenance, formatFingerprints, formatForgiven, formatTipProof, runEndTipProof, } from "../../run/daemon.js";
+import { formatSpan, WALL_PRIORITY, WALL_PRIORITY_TEXT, wallBudget, wallBudgetFacts } from "../../run/wall-budget.js";
 import { deriveRunCockpitData } from "../../tui/cockpit/derive.js";
+import { cellWidth, wrapCells } from "../../tui/cockpit/width.js";
 const n = (x) => x.toLocaleString("en-US"); // explicit locale — CI/darwin flake guard
 const EM = "—";
 const firstLine = (s) => {
@@ -75,6 +78,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.
@@ -89,6 +130,192 @@ const supersession = (events) => {
     const supersedes = typeof start?.data.supersedes === "string" ? start.data.supersedes : undefined;
     return { ...(typeof by === "string" ? { supersededBy: by } : {}), ...(supersedes ? { supersedes } : {}) };
 };
+// ── CG1 (v2.6.4): the lead — what finished, where the wall went, what needs you NOW ──────────────
+// Status and report open with the same three lines, folded here once. Finished work and first pass
+// come from this journal's own lineage; time is the existing disjoint wall partition (never summed
+// task-time); outstanding is the CURRENT owed-check fold, re-read on every call, never the run-end copy.
+// Rows that prove a task's lineage was not one uninterrupted dispatch: a park, an approval, a failure,
+// a repair, or a restart restoring it.
+const INTERRUPTED = new Set(["task-human", "task-failed", "task-approved", "repair-dispatch", "resume-restore"]);
+/**
+ * End-to-end first pass over the finished tasks of the SELECTED journal (no cross-run scan). A task
+ * closed done, merged, or named done by the newest run-end passes only as one dispatch at attempt 0
+ * straight to its merge. A task whose predecessor or dispatch evidence is missing — no run-start, a run
+ * that supersedes another, no dispatch, a first dispatch not at attempt 0 or not recording lifetime
+ * worker dispatch ordinal 0 — is unknown whatever else it shows: attempts reset at every release, so
+ * only the lifetime ordinal proves no earlier dispatch is missing. Otherwise any park, approval, failure, repair, restore or second dispatch is a known miss — a
+ * run-end summary's park or a restart before its merge included — and a would-be pass with no merge is
+ * unknown, never counted as a pass.
+ */
+export function endToEndFirstPass(events) {
+    const start = events.find((e) => e.event === "run-start");
+    const predecessorUnread = !start || typeof start.data.supersedes === "string";
+    const runEnd = [...events].reverse().find((e) => e.event === "run-end");
+    const finished = new Set([
+        ...events.flatMap((e) => e.taskId && (e.event === "task-done" || e.event === "merge") ? [e.taskId] : []),
+        ...(Array.isArray(runEnd?.data.done) ? runEnd.data.done.map(String) : []),
+    ]);
+    const fp = { passed: 0, known: 0, unknown: 0 };
+    const names = (e, buckets, taskId) => e.event === "run-end"
+        && buckets.some((b) => Array.isArray(e.data[b]) && e.data[b].map(String).includes(taskId));
+    for (const taskId of finished) {
+        const own = events.filter((e) => e.taskId === taskId);
+        const dispatches = own.filter((e) => e.event === "task-dispatch");
+        // Run-level rows name the task too: a run-end summary parking or failing it is a park wherever it
+        // sits, and between its first dispatch and its merge any not-done bucket or a restart means the
+        // lineage crossed an engagement boundary — never one uninterrupted dispatch.
+        const at = events.findIndex((e) => e.taskId === taskId && e.event === "task-dispatch");
+        const end = events.findIndex((e) => e.taskId === taskId && e.event === "merge");
+        const span = at < 0 ? [] : events.slice(at, end < 0 ? undefined : end);
+        const crossed = events.some((e) => names(e, ["human", "failed"], taskId))
+            || span.some((e) => e.event === "run-resume" || names(e, ["blocked", "pending"], taskId));
+        // Missing predecessor or dispatch evidence is unknown BEFORE any outcome is classified: a park read
+        // without its initial dispatch (none, a first one past attempt 0, or one whose lifetime ordinal is
+        // unrecorded or past 0), or in a run continuing an unread predecessor, is no known miss either.
+        const origin = dispatches[0]?.data;
+        if (predecessorUnread || origin?.attempt !== 0 || origin.workerDispatchOrdinal !== 0)
+            fp.unknown++;
+        else if (dispatches.length > 1 || crossed || own.some((e) => INTERRUPTED.has(e.event)))
+            fp.known++;
+        else if (!own.some((e) => e.event === "merge"))
+            fp.unknown++;
+        else {
+            fp.passed++;
+            fp.known++;
+        }
+    }
+    return fp;
+}
+export const firstPassText = ({ passed, known, unknown }) => known === 0 && unknown > 0
+    ? `end-to-end first pass unknown (${unknown} without lineage)`
+    : `end-to-end first pass ${passed}/${known}${unknown ? ` + ${unknown} unknown` : ""}`;
+/** The CURRENT owed-check fold. `cwd` is any checkout of the run's repository. */
+export const currentOwed = (events, cwd = process.cwd()) => foldOwedChecks(events, cwd);
+export const outstandingText = (fold) => fold.known
+    ? `outstanding ${fold.debt}${fold.outstanding.length ? ` (${fold.outstanding.map((o) => `${o.taskId} ${o.gate}`).join(", ")})` : ""}`
+    : "outstanding unknown";
+// A run-end summary's buckets read as the lifecycle row each names; later effective rows move them on.
+const SUMMARY_STATE = { done: "task-done", failed: "task-failed", human: "task-human", blocked: "task-blocked", pending: "task-pending" };
+/**
+ * Tasks the CURRENT lifecycle leaves waiting on the operator: every run-end summary sets the tasks its
+ * buckets name, and each effective lifecycle row after it moves its task on — so a summary naming a
+ * park or failure the task rows never wrote still counts, and a later approval or merge clears it.
+ */
+const waitingOnYou = (events) => {
+    const last = new Map();
+    for (const e of effectiveEvents(events)) {
+        if (e.event === "run-end") {
+            for (const [bucket, state] of Object.entries(SUMMARY_STATE)) {
+                if (Array.isArray(e.data[bucket]))
+                    for (const id of e.data[bucket])
+                        last.set(String(id), state);
+            }
+        }
+        else if (e.taskId && ["task-dispatch", "task-done", "task-failed", "task-human", "task-approved", "merge"].includes(e.event))
+            last.set(e.taskId, e.event);
+    }
+    const states = [...last.values()];
+    return { parked: states.filter((s) => s === "task-human").length, failed: states.filter((s) => s === "task-failed").length };
+};
+export const needsYouText = (events, owed) => {
+    const { parked, failed } = waitingOnYou(events);
+    const why = owed.known ? "" : ` · unknown: ${owed.unknown[0]?.reason ?? "owed checks unreadable"}`;
+    return `needs you: ${outstandingText(owed)} · ${parked} parked · ${failed} failed${why}`;
+};
+/** The wall window alone, for the one-line form: the same partition, never task-time. */
+export const wallText = (events) => {
+    const budget = wallBudget(events);
+    return budget ? `${formatSpan(budget.wallMs)} wall` : "wall not measurable";
+};
+/** Time: the existing disjoint wall partition's window and its largest exposed buckets — never task-time. */
+const timeLead = (events) => {
+    const budget = wallBudget(events);
+    if (!budget)
+        return "time not measurable — the journal names no run-start with a readable timestamp";
+    const top = [...WALL_PRIORITY.map((bucket) => [bucket, budget.exposedMs[bucket]]), ["residual", budget.residualMs]]
+        .filter(([, ms]) => ms > 0).sort((a, b) => b[1] - a[1]).slice(0, 3);
+    return `time ${formatSpan(budget.wallMs)} wall, each instant once${top.length ? `: ${top.map(([bucket, ms]) => `${bucket} ${formatSpan(ms)}`).join(" · ")}` : ""}`;
+};
+/**
+ * The three lead lines. `finished` is the surface's own done tally and tip reading (plus any
+ * comparability or supersession note); the rest is folded here from the journal and the current fold.
+ */
+export function leadLines(events, owed, finished) {
+    return [
+        `finished ${[finished.tally, finished.tip, firstPassText(endToEndFirstPass(events)), ...(finished.notes ?? [])].join(" · ")}`,
+        timeLead(events),
+        needsYouText(events, owed),
+    ];
+}
+/**
+ * A lead line packed into `columns` at its ` · ` fact boundaries: a fact that does not fit beside the
+ * last moves whole to a `prefix`ed continuation row, so narrowing costs rows and never drops a fact.
+ */
+const wrapFacts = (line, columns, prefix) => {
+    const rows = [];
+    // Read fact by fact without a hand-split (the learning-section source pin forbids one here).
+    for (const [, fact] of line.matchAll(/(?:^| · )(.+?)(?= · |$)/gu)) {
+        const last = rows.at(-1);
+        if (last !== undefined && cellWidth(`${last} · ${fact}`) <= columns)
+            rows[rows.length - 1] = `${last} · ${fact}`;
+        else
+            rows.push(...wrapCells(last === undefined ? fact : `${prefix}${fact}`, columns, { continuationPrefix: "  " }));
+    }
+    return rows;
+};
+const LEAD_LABELS = ["finished", "time", "needs you"];
+/**
+ * The lead at `columns`: the first row of finished, time and needs you are the first three physical
+ * lines, and every continuation follows them, naming the lead it continues.
+ */
+export const leadRows = (lead, columns) => {
+    const wrapped = lead.map((line, i) => wrapFacts(line, columns, `  ${LEAD_LABELS[i]}: `));
+    return [...wrapped.map((rows) => rows[0]), ...wrapped.flatMap((rows) => rows.slice(1))];
+};
+/**
+ * The discharge rows the current fold validates ON THEIR OWN: each is folded alone, at its own journal
+ * position among every non-discharge row, so one valid proof never lends its validity to a refused
+ * sibling naming the same check, and a proof written before its obligation is never validated by it.
+ */
+const validatedDischarges = (events, cwd) => {
+    return events.filter((e) => e.event === OWED_DISCHARGE_EVENT).flatMap((row) => {
+        const ids = Array.isArray(row.data.ids) ? row.data.ids.map(String) : [];
+        // In journal order: a discharge that precedes its obligation stays where it was written, never moved after it.
+        const fold = currentOwed(events.filter((e) => e.event !== OWED_DISCHARGE_EVENT || e === row), cwd);
+        if (!ids.length || !ids.every((id) => fold.discharged.includes(id)))
+            return [];
+        return [{ row, gates: ids.map((id) => fold.acceptedRisk.find((o) => o.id === id)?.gate ?? "unknown") }];
+    });
+};
+/** A leg2 row's own reviewer fact: top-level, or under the verify gate row's meta it spreads. */
+const leg2Seat = (data, key) => data[key] ?? (typeof data.meta === "object" && data.meta !== null ? data.meta[key] : undefined);
+/**
+ * A review-leg2 row supersedes the daemon review only through its OWN validated discharge of a review
+ * check: a passing row whose artifact was captured, bound to that discharge's artifact and range, and
+ * naming the very reviewer seat (key and vendor) the discharge validated. A failed or capture-failed
+ * row, or one naming another seat, never borrows a sibling's proof.
+ */
+const leg2Discharge = (leg2, validated) => {
+    const d = leg2.data;
+    if (d.pass !== true || d.artifactAvailability !== "available" || typeof d.artifactSha256 !== "string")
+        return undefined;
+    return validated.find(({ row, gates }) => {
+        const seat = row.data.reviewer;
+        return row.taskId === leg2.taskId && gates.includes("review")
+            && row.data.artifactSha256 === d.artifactSha256 && row.data.artifactPath === d.artifactPath
+            && row.data.head === d.head && row.data.mergeBase === d.mergeBase
+            && typeof seat?.key === "string" && leg2Seat(d, "reviewer") === seat.key && leg2Seat(d, "vendor") === seat.vendor;
+    })?.row;
+};
+const RUN_END_BUCKETS = ["done", "failed", "human", "blocked", "pending"];
+/** The record's done tally: tasks closed done in the journal or its newest run-end, over every task it names. */
+const recordTally = (events) => {
+    const runEnd = [...events].reverse().find((e) => e.event === "run-end");
+    const bucket = (key) => Array.isArray(runEnd?.data[key]) ? runEnd.data[key].map(String) : [];
+    const done = new Set([...bucket("done"), ...events.flatMap((e) => e.taskId && (e.event === "task-done" || e.event === "merge") ? [e.taskId] : [])]);
+    const all = new Set([...done, ...RUN_END_BUCKETS.flatMap(bucket), ...events.flatMap((e) => e.taskId && e.event.startsWith("task-") ? [e.taskId] : [])]);
+    return `${done.size}/${all.size} done`;
+};
 const taskIds = (events) => {
     const seen = new Set();
     const out = [];
@@ -194,7 +421,7 @@ const fingerprintClauses = (data) => {
         + `; 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, cwd) {
     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;
@@ -218,7 +445,11 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
     if (!usageLines.length)
         usageLines.push("- **not recorded:** attempts/windows: not measurable; tokens: not measurable; price: not measurable");
     const sup = supersession(events);
+    const owed = currentOwed(events, cwd);
+    const validated = validatedDischarges(events, cwd);
     const lines = [
+        ...leadLines(events, owed, { tally: recordTally(events), tip: `tip verify ${verificationOf(runId, events)}` }).map((line) => `- ${line}`),
+        "",
         `# tickmarkr engagement`,
         "",
         `- **runId:** ${runId}`,
@@ -237,11 +468,17 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         "",
         ...usageLines,
         `- **wall-clock:** ${wallClock(runStart, runEnd)}`,
-        `- **first-attempt rate:** ${firstAttemptRate}`,
+        `- **end-to-end first pass:** ${firstPassText(endToEndFirstPass(events)).replace("end-to-end first pass ", "")} — this journal's dispatch, park, approval and merge lineage`,
+        `- **first-attempt rate (engagement-local telemetry):** ${firstAttemptRate} — attempts restart at every resume`,
         `- **gate failures:** ${[...gateFailures.entries()].map(([gate, failures]) => `${gate}: ${failures}`).join(", ") || "none recorded"}`,
         `- **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);
@@ -304,7 +541,12 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
                 const identityText = identity
                     ? `reviewer ${identity.reviewer}${identity.vendor ? ` (vendor: ${identity.vendor}; provider: ${identity.provider})` : ` (provider: ${identity.provider})`}`
                     : firstLine(row.data.details);
-                lines.push(`  - review-leg2: ${pass} (supersedes daemon review) — ${identityText}`);
+                // CG1: only this row's own validated discharge of a review check lets it supersede the daemon review.
+                const discharge = leg2Discharge(row, validated);
+                const claim = discharge
+                    ? `supersedes daemon review — validated discharge ${discharge.data.ids.map(String).join(", ")}`
+                    : "unvalidated — no validated owed-check discharge; the daemon review stands";
+                lines.push(`  - review-leg2: ${pass} (${claim}) — ${identityText}`);
             }
         }
         else
@@ -326,7 +568,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) {
@@ -377,17 +619,28 @@ function textReport(runId, events, rows, cwd) {
     const consults = events.filter((e) => e.event === "consult-verdict").length;
     const failovers = events.filter((e) => e.event === "quota-failover").length;
     const sup = supersession(events);
+    // CG1: at a configured terminal width the lead wraps its continuations after the three lead lines;
+    // report() fits every other row of the complete output (fitColumns).
+    const lead = leadLines(events, currentOwed(events, cwd), { tally: recordTally(events), tip: `tip verify ${verificationOf(runId, events)}` });
+    const columns = process.stdout.columns;
     return [
+        ...(columns ? leadRows(lead, columns) : lead),
         `tickmarkr engagement — ${runId}`,
         ...(sup.supersededBy ? [`superseded by ${sup.supersededBy}`] : []),
         ...(sup.supersedes ? [`supersedes ${sup.supersedes}`] : []),
         "",
-        "engagement summary — audit trail:",
+        // CG1: the telemetry rows are engagement-local — attempts restart at every resume; the lead's
+        // end-to-end first pass is the lineage reading.
+        "engagement summary — audit trail: engagement-local telemetry, attempts restart at every resume",
         ...[...groups.entries()].map(([k, g]) => `  ${k.padEnd(30)} tasks ${g.rows.length}, attempts ${g.rows.reduce((s, r) => s + r.attempts, 0)}, done ${g.rows.filter((r) => r.outcome === "done").length}`),
         "",
         `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:",
@@ -399,6 +652,14 @@ function textReport(runId, events, rows, cwd) {
         `  probes this run (route-deviation explore): ${probes}`,
     ].join("\n");
 }
+/**
+ * CG1: at a configured terminal width EVERY row of the complete text output fits it — the lead, the
+ * body, a --bundle receipt and --compare output alike: a row that overflows wraps beneath its own
+ * indent, no fact dropped; a row that already fits (the lead's own layout) is untouched.
+ */
+const fitColumns = (out, columns = process.stdout.columns) => columns
+    ? out.replace(/^.*$/gmu, (line) => wrapCells(line, columns, { continuationPrefix: `${/^ */u.exec(line)[0]}  ` }).join("\n"))
+    : out;
 // T4 (v1.50): TTY-only brand pass over the text report — title frame + dim section chrome; row
 // text and alignment untouched (the doctor/status system). Gated on ttyVisual(): the non-TTY
 // surface returns untouched, and --md never styles (the record is a document surface).
@@ -406,8 +667,8 @@ const stylizeReport = (out) => {
     if (!ttyVisual())
         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(/^tickmarkr engagement — .*$/m, (head) => `${title(head)}\n${rule()}`) // non-global /m ⇒ the title line only
+        .replace(/^(engagement summary — audit trail:[^\n]*|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({
@@ -428,6 +689,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.
@@ -453,8 +715,13 @@ export async function report(argv, cwd = process.cwd()) {
             throw new Error(outcome.reason);
         comparison = "\n" + outcome.text;
     }
+    // CG1: the bundle receipt follows the three lead lines and their wrapped continuations, never above
+    // them (in markdown, after the blank line that closes the lead list, so it never joins its last item).
+    const afterLead = (out, at = 3) => bundleNote
+        ? out.replace(new RegExp(`^(?:[^\\n]*\\n){${at}}(?:  [^\\n]*\\n)*`, "u"), (lead) => `${lead}${bundleNote.trimEnd()}\n`)
+        : out;
     if (values.md) {
-        return bundleNote + renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows) + comparison;
+        return afterLead(renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows, suite, cwd), 4) + comparison;
     }
-    return bundleNote + stylizeReport(textReport(runId, events, rows, cwd)) + comparison;
+    return fitColumns(afterLead(stylizeReport(textReport(runId, events, rows, cwd, suite))) + comparison);
 }

package/dist/cli/commands/resume.js

@@ -5,10 +5,8 @@ import { classifyHost, parseDriverOverride, pickDriver, preflightHostDriver } fr
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
-import { narrationSink, bindNarration } from "./run.js";
+import { finalRail, narrationSink, bindNarration, summaryGreen } from "./run.js";
 import { assertRefsWritable } from "../../run/git.js";
-const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
-    && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
     const { values, positionals } = parseArgs({
         args: argv,
@@ -56,6 +54,6 @@ export async function resume(argv, cwd = process.cwd()) {
         // the operator named, so a resumed run's lifecycle rows name THIS run and not a generic word.
         narrate,
     });
-    const out = `resumed ${s.runId} — ${formatSummary(s)}`;
+    const out = `resumed ${s.runId} — ${formatSummary(s)}${finalRail(s, cwd)}`;
     return { out, code: summaryGreen(s) ? 0 : 2 };
 }

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

@@ -1,4 +1,5 @@
 import type { ExecutorDriver } from "../../drivers/types.js";
+import { type RunSummary } from "../../run/daemon.js";
 import { type JournalEvent } from "../../run/journal.js";
 /** Closed repetitive set the rail suppresses on a TTY. An ungated `phase-start` joins them below —
  *  it is a phase counter, while a phase-start CARRYING a gate is the gate start the rail draws. */
@@ -64,6 +65,16 @@ export declare const narrationSink: (runId: string) => (event: JournalEvent) =>
  * wrap their driver here so neither can forget the binding.
  */
 export declare function bindNarration<D extends ExecutorDriver>(driver: D, narrate: (event: JournalEvent) => void): D;
+/** Execution green: the exit-code predicate run and resume share. Users' scripts read it; debt never moves it. */
+export declare const summaryGreen: (s: RunSummary) => boolean;
+/**
+ * CG2 (v2.6.4): the last line of a run or resume, read from the CURRENT owed-check fold after the
+ * daemon returns — never the run-end row's copy, which a later `verify --record` discharge leaves
+ * historical. "verified" requires execution green AND outstanding empty AND known; an execution-green
+ * run that owes a check, or whose debt is unknown, says so and is not green. A partial or failed run
+ * adds nothing: its summary keeps its own wording and is never called complete.
+ */
+export declare function finalRail(s: RunSummary, cwd: string): string;
 export declare function run(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;

package/dist/cli/commands/run.js

@@ -6,10 +6,11 @@ import { loadGraph, onDiskSpecHash, readCompileRefusal } from "../../graph/graph
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
 import { isRunLockLive } from "../../run/lock.js";
 import { route, NO_EXPLORE_ENV } from "../../route/router.js";
-import { formatJournalNarration, loadRoutingProfile, newRunId } from "../../run/journal.js";
+import { formatJournalNarration, Journal, loadRoutingProfile, newRunId } from "../../run/journal.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
+import { currentOwed, outstandingText } from "./report.js";
 import { assertRefsWritable } from "../../run/git.js";
 // ── the operator event rail (v1.99 T2) ──────────────────────────────────────────────────────────
 // A run's TTY narration is an operator EVENT RAIL, not the journal dump it used to echo. The
@@ -166,17 +167,25 @@ const bucket = (value) => (Array.isArray(value) ? value.length : 0);
  *
  *   a fatal crash, a failed task or a failed integration tip is a FAILURE;
  *   an incomplete run — parked, blocked or still-pending work — wants ATTENTION;
+ *   so does a complete execution that owes a check, or whose owed-check fold is unknown (CG2);
  *   only a run with none of those is a pass.
  *
  * A rail that paints the terminal record by the same predicate the exit code uses can never show a
- * green tickmark over a run whose exit code is 2.
+ * green tickmark over a run whose exit code is 2 — and, since the exit code is execution-based, the
+ * debt clause is the one place the tone is stricter than it: exit 0 with an owed check is not green.
+ * The fold is the one this row carries, reduced at its own append: live, that IS the current fold.
  */
 const runEndTone = (data) => {
     if (data.fatal === true || bucket(data.failed) > 0 || data.tipVerify === "failed")
         return "fail";
     if (bucket(data.human) + bucket(data.blocked) + bucket(data.pending) > 0)
         return "attention";
-    return "pass";
+    return recordedDebt(data) === 0 ? "pass" : "attention";
+};
+/** The outstanding count a run-end record's own fold carries; undefined when it carries none or an unknown one. */
+const recordedDebt = (data) => {
+    const owed = data.owedChecks;
+    return owed?.known === true && Array.isArray(owed.outstanding) ? owed.outstanding.length : undefined;
 };
 /** A gate row's non-failure is spelled across `pass`, `skipped`, `verdict` and `infra`, and a row may
  *  state NONE of them (src/run/outcome.ts) — so the rail reads the canonical outcome rather than
@@ -330,6 +339,8 @@ const RAIL_PROJECTION = {
     "tip-moved": (d) => typeof d.gatedCommit === "string" && typeof d.branchTip === "string"
         ? `gated ${d.gatedCommit.slice(0, 12)}, tip ${d.branchTip.slice(0, 12)}`
         : undefined,
+    // CG2: the terminal row names its debt — a legacy record without a fold is unknown, never zero
+    "run-end": (d) => `outstanding ${recordedDebt(d) ?? "unknown"}`,
     "trust-auto-answer": (d) => typeof d.adapter === "string" ? `${d.adapter}${typeof d.phase === "string" ? ` ${d.phase}` : ""}` : undefined,
     // SB-1: the census the ceiling released beside, and the budget the round ran under versus the one it
     // would have had on an empty census — none of `{count, occupancyCap, conservativeCap}` is on the ladder
@@ -420,8 +431,25 @@ export function bindNarration(driver, narrate) {
     driver.narrateWith?.(narrate);
     return driver;
 }
-const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
+/** Execution green: the exit-code predicate run and resume share. Users' scripts read it; debt never moves it. */
+export const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
+/**
+ * CG2 (v2.6.4): the last line of a run or resume, read from the CURRENT owed-check fold after the
+ * daemon returns — never the run-end row's copy, which a later `verify --record` discharge leaves
+ * historical. "verified" requires execution green AND outstanding empty AND known; an execution-green
+ * run that owes a check, or whose debt is unknown, says so and is not green. A partial or failed run
+ * adds nothing: its summary keeps its own wording and is never called complete.
+ */
+export function finalRail(s, cwd) {
+    if (!summaryGreen(s))
+        return "";
+    const owed = currentOwed(Journal.open(cwd, s.runId).read(), cwd);
+    if (owed.known && owed.outstanding.length === 0)
+        return `\nverified — execution complete, ${outstandingText(owed)}`;
+    const why = owed.known ? "" : ` (${owed.unknown[0]?.reason ?? "owed checks unreadable"})`;
+    return `\nexecution complete; ${outstandingText(owed)}${why} — not green until outstanding is empty and known`;
+}
 // v1.51 T2: --quality is a pure compatibility alias for `--mode partner-led` (this run only). It
 // carries no one-band floor raise of its own — and since the OBS-89 rip (v1.60) route() no longer
 // reads the retired TICKMARKR_QUALITY env at all, so no downstream code can raise a floor on its
@@ -526,7 +554,7 @@ export async function run(argv, cwd = process.cwd()) {
             supersedes: values.supersedes,
             narrate,
         });
-        const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+        const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)${finalRail(s, cwd)}`;
         return { out, code: summaryGreen(s) ? 0 : 2 };
     }
     finally {