tickmarkr 2.6.3 → 2.6.4

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

@@ -1,5 +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[], suite?: BaselineCommand): 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

@@ -11,10 +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_TEXT, wallBudget, wallBudgetFacts } from "../../run/wall-budget.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) => {
@@ -129,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 = [];
@@ -234,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 = [], suite) {
+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;
@@ -258,7 +445,11 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = [], suit
     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}`,
@@ -277,7 +468,8 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = [], suit
         "",
         ...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}`,
@@ -349,7 +541,12 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = [], suit
                 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
@@ -422,12 +619,19 @@ function textReport(runId, events, rows, cwd, suite) {
     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}` : ""}`,
@@ -448,6 +652,14 @@ function textReport(runId, events, rows, cwd, suite) {
         `  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).
@@ -455,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:|wall budget — [^\n]*|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({
@@ -503,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, suite) + comparison;
+        return afterLead(renderMarkdownRecord(runId, events, estimateCosts(rows, cfg.cost), rows, suite, cwd), 4) + comparison;
     }
-    return bundleNote + stylizeReport(textReport(runId, events, rows, cwd, suite)) + 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 {

package/dist/cli/commands/status.js

@@ -12,6 +12,7 @@ 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 { currentOwed, endToEndFirstPass, firstPassText, leadLines, leadRows, needsYouText, wallText } from "./report.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";
@@ -448,6 +449,8 @@ export const shortGoal = (goal, max) => {
 };
 /** Columns the machine row always spends on the task title, however long its machinery segment runs. */
 const MACHINE_TITLE_FLOOR = 24;
+/** The plain print's own width when none is configured: its machine rows are laid out, and parsed whole, at it. */
+const MACHINE_COLUMNS = 120;
 // The approved task board derives an area from files[] rather than adding another graph field.
 // Known tickmarkr domains keep their reviewed names; other repositories fall back to their first
 // meaningful path segment so the shipped surface never turns a foreign project into UNMAPPED rows.
@@ -1037,7 +1040,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     // SUP-01: derived by stat() alone, from THIS frame's clock. status stays a reader — nothing here
     // creates, touches or reaps a beat file, so an absent supervision dir stays absent.
     const supervision = readSupervision(cwd, now);
-    const width = process.stdout.columns ?? 120;
+    const width = process.stdout.columns ?? MACHINE_COLUMNS;
     const done = journalRowsOnly
         ? recordedDone(renderedTasks, taskRows)
         : effective.tasks.filter((task) => task.status === "done").length;
@@ -1055,6 +1058,16 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
         if (!taskIds.has(taskId))
             phases.delete(taskId);
     const hotPhase = [...phases.values()].sort((a, b) => a.order - b.order).at(-1);
+    // CG1: the three lead lines — finished, wall, needs you from the CURRENT owed-check fold — open
+    // every frame, plain and terminal; the header below keeps every comparability, supersession and verify fact.
+    const lead = runId
+        ? leadLines(events, currentOwed(events, cwd), {
+            // The header's own rule: while the tip is unverified the tally never reads as a finished run.
+            tally: comparable ? tipPhase ? `${done}/${total} tasks done` : `${done}/${total} done` : NOT_COMPARABLE_CLAIM,
+            tip: verify ? `tip ${verify}` : "tip verify pending",
+            notes: supersededBy ? [`superseded by ${supersededBy}`] : [],
+        }).map(sanitizeTaskText)
+        : [];
     // 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.
@@ -1151,8 +1164,16 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
             ? `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)}`;
+        // At its machine width and wider the plain print keeps each machine row whole — one row per task and
+        // its evidence line after it, which consumers parse. A configured width narrower than that holds for
+        // EVERY row: one that overflows wraps beneath its own indent, its identity kept on the first.
+        const body = [header, legendLine, `  ${supervisionText(supervision, divider)}`, ...rows];
+        const wrapRow = (line) => wrapCells(line, width, { continuationPrefix: `${/^ */u.exec(line)[0]}  ` });
         return {
-            content: [header, legendLine, `  ${supervisionText(supervision, divider)}`, ...rows].join("\n"),
+            content: [
+                ...leadRows(lead, width),
+                ...(width >= MACHINE_COLUMNS ? body : body.flatMap(wrapRow)),
+            ].join("\n"),
             ...(hotPhase ? { hotPhase } : {}),
             ...(runId ? { runId } : {}),
             workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
@@ -1349,6 +1370,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     const effort = effortPanel(g.tasks, record && !comparable ? undefined : events, boardColumns);
     return {
         content: boardRows([
+            ...leadRows(lead, boardColumns),
             ...headerRows,
             ...nowLine,
             supervisionLegend,
@@ -1404,7 +1426,12 @@ const oneLine = (cwd, namedRunId) => {
             `verify ${recordedVerify(record.events)}`,
         ]
         : [NOT_COMPARABLE_CLAIM, "verify unavailable"];
-    return sanitizeTaskText([record.runId, ...claims].join(" · "));
+    // CG1: the lead's facts in one line — lineage first pass, the wall window, and what needs you from
+    // the CURRENT fold, so a discharge after run-end moves this line too.
+    const { events } = record;
+    return sanitizeTaskText([
+        record.runId, ...claims, firstPassText(endToEndFirstPass(events)), wallText(events), needsYouText(events, currentOwed(events, cwd)),
+    ].join(" · "));
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     if (argv.some((arg) => arg === "--help" || arg === "-h"))