tickmarkr 2.6.3 → 2.6.5

package/dist/cli/commands/init.js

@@ -111,7 +111,7 @@ Before \`tickmarkr compile\` or \`tickmarkr run\`: run \`tickmarkr version\`, re
 
 ### Tip-verify-before-green
 
-A run is green only when ALL of these hold: the run-end event exists in the journal, tip verify is not "failed", AND the run-end summary's \`failed\`, \`human\`, \`blocked\` and \`pending\` buckets are every one of them empty. The shorter "run-end plus tip verify" form is NOT sufficient: a run ending \`done=[T1,T3,T4] human=[T2] tipVerify=passed\` is a closed PARTIAL run — three of four delivered, one parked — and calling it green is how a park becomes invisible. Never report green to the operator, tab titles, or records until every clause holds; when one does not, name the bucket that is not empty.
+A run is green only when ALL of these hold: the run-end event exists in the journal, tip verify is not "failed", the run-end summary's \`failed\`, \`human\`, \`blocked\` and \`pending\` buckets are every one of them empty, AND the owed checks in CURRENT \`tickmarkr status <runId>\` are outstanding empty AND known (\`outstanding 0\`; \`outstanding unknown\` is never empty). The shorter "run-end plus tip verify" form is NOT sufficient: a run ending \`done=[T1,T3,T4] human=[T2] tipVerify=passed\` is a closed PARTIAL run — three of four delivered, one parked — and calling it green is how a park becomes invisible. Empty execution buckets are not sufficient either (D-660): a run ending with every execution bucket empty and \`tipVerify=passed\` after an operator waived one review still owes that accepted-risk review check — status reads \`outstanding 1 (T7 review)\`, and \`tickmarkr run\` and \`resume\` exit 0 on execution alone — so it is execution complete, not green. Read the debt from CURRENT status, never from the run-end record: a \`tickmarkr verify --record <runId>\` discharge that lands after run-end moves current status to \`outstanding 0\` while the historical run-end row still carries 1, and only then is that run green; a legacy waiver without a recorded obligation reads \`outstanding unknown\` and is never green. Never report green to the operator, tab titles, or records until every clause holds; when one does not, name the bucket that is not empty, the outstanding checks, or the unknown debt.
 
 ### Verified handoffs
 
@@ -132,7 +132,11 @@ you were handed the whole picture — list the repository root, open every guida
 - **The gates are the product.** Seven, defined in \`src/graph/schema.ts\`:
   \`build test lint evidence scope acceptance review\`. **That is DECLARATION order, not execution order** —
   the first five run as a battery that stops at its first red, then \`acceptance\` and \`review\` run
-  CONCURRENTLY (\`run-gates.ts:39\`, *"judge ‖ review"*). The first five are MANDATORY; only \`acceptance\` and
+  CONCURRENTLY (\`run-gates.ts:39\`, *"judge ‖ review"*). One repair reorders them: a repair the REVIEW sent
+  back (carried \`review:material\`, test selection on, no required repair test) runs build, lint, evidence and
+  scope, then \`acceptance\` ‖ \`review\`, then its test screen, so a review that re-reds an unchanged subject
+  starts no test at all; a test-red repair keeps the battery first. Either way nothing merges until the FULL
+  suite has passed on the merge-candidate commit. The first five are MANDATORY; only \`acceptance\` and
   \`review\` may be omitted per task. Implementations are in \`src/gates/\` — \`baseline.ts\` (build/test/lint,
   diffed against a recorded baseline so pre-existing failures are forgiven), \`evidence.ts\`, \`scope.ts\`,
   \`acceptance.ts\` (its judge reads the DIFF and every criterion must cite a changed hunk), \`review.ts\`
@@ -634,7 +638,8 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     const output = io.output ?? process.stdout;
     const interactive = input.isTTY === true && output.isTTY === true && !(values.yes ?? false);
     // Act 1 — preferences. Only when the repo config does not exist yet: init never rewrites an
-    // operator's config; re-tuning is `tickmarkr fleet` (act 3 below still runs and writes overlays).
+    // operator's config; re-tuning is `tickmarkr fleet` (act 3 below still runs). Act 1 writes only
+    // project execution preferences; model choices are act 3's, saved to the USER overlay (B2).
     if (!repoConfigExists) {
         if (interactive) {
             emitBanner();
@@ -671,7 +676,8 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
         : await doctor([], cwd, undefined, { banner: false, compact: interactive });
     // Act 3 — fleet. The compact discovery surface prints BETWEEN the acts so the operator reads
     // what the fleet browser (and its presets overlay, raised on the first Shapes entry) ranks
-    // with; the final summary then carries a pointer, not a repeat.
+    // with; the final summary then carries a pointer, not a repeat. Its confirmation is the shared
+    // Fleet actuator's: the reviewed choices land in the user overlay (gdir), never the repo's.
     if (interactive) {
         output.write(`${doc}\n`);
         doc = "discovery shown above — full matrix any time with `tickmarkr doctor`";

package/dist/cli/commands/plan.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
+import { aliasIdentityHeadlines } from "../../adapters/model-discovery-check.js";
 import { formatModelAuthLine, contextWindowLints, modelLints, preferEntryLints, ttyVisual } from "../../adapters/model-lints.js";
 import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
@@ -15,9 +16,10 @@ import { disallowedBy, excludedChannels, exclusionLine, observedSeat, routingEnt
 import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.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 { carriedAuthorVendors, gateReviewerFloor, modelId, modelProvider, pickReviewer } from "../../gates/review.js";
 import { Journal, loadRoutingProfile, readProfileCursor, recordedGraphDefinitionHash, RUNS_WINDOW } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
+import { codexCommitHeadline } from "../../adapters/codex-commit-check.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
 import { runLockRunId, runStatusLine } from "../../run/lock.js";
@@ -135,6 +137,13 @@ async function taskInputFindings(tasks, cwd) {
     }
     return findings;
 }
+/**
+ * v2.6.5 T9 (D-862): a task the run never dispatched gates under the fresh route's author, so plan can
+ * mirror its review eligibility exactly. Once dispatched, resume state only the daemon decides (a restored
+ * or failed-over author, a tier climb, carried commits, a parked recheck) picks the author — fail closed.
+ * ponytail: unknown, not exact; call production's own resume functions once daemon.ts can export them (POOL).
+ */
+const resumeDecidesAuthor = (events, taskId) => events.some((row) => row.taskId === taskId && row.event === "task-dispatch");
 // v1.89 T4: harnessFrom is the resolver's INPUT — a caller (the byte-pinned goldens) fixes the location
 // and keeps this machine's absolute paths out of a fixture. The default is the INVOKED entrypoint,
 // `process.argv[1]`: the bin symlink a global install puts on PATH, which resolves to dist/cli/index.js.
@@ -183,6 +192,26 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
             .map((event) => event.data.reviewer)
         : [];
+    // daemon.ts replayedReviewerExclusions: a journaled review-pool-demotion is excluded from every review
+    // pick of the resumed run this plan previews (reviewer role only).
+    const replayedReviewerExclusions = [...new Set((matchingEvents ?? [])
+            .filter((event) => event.event === "review-pool-demotion" && typeof event.data.reviewer === "string")
+            .map((event) => event.data.reviewer))];
+    const demotedReviewers = new Set(replayedReviewerExclusions);
+    // daemon.ts demotedChannels: the resumed run's worker exclusions (journal replayExcludedChannels).
+    const runJournal = matchingRunId ? Journal.open(cwd, matchingRunId) : undefined;
+    const demotedWorkers = runJournal?.replayExcludedChannels() ?? new Set();
+    // run-gates.ts retired (OBS-1025 add.2): seats with two no-verdicts this run are out of every pick, tallied
+    // as daemon.ts seeds reviewNoVerdicts — noVerdict rows only, and a checkout-proof timeout never strikes.
+    const noVerdicts = new Map();
+    for (const event of matchingEvents ?? []) {
+        if (event.event !== "review-no-verdict" || event.data.noVerdict !== true || typeof event.data.reviewer !== "string")
+            continue;
+        if (event.data.cause === "seat-launch-failed" && event.data.launchCause === "checkout-proof-timeout")
+            continue;
+        noVerdicts.set(event.data.reviewer, (noVerdicts.get(event.data.reviewer) ?? 0) + 1);
+    }
+    const retiredReviewers = [...noVerdicts].filter(([, n]) => n >= 2).map(([seat]) => seat);
     // OBS-947 repair: a resumed run re-dispatches only tasks whose replayed status is pending (or that the
     // journal never mentions). done, failed and human are all skipped alike, so rendering their preview
     // picks must not advance the shared reviewHistory — a phantom draw wraps the LRU and makes a later
@@ -243,6 +272,10 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
     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`, "");
     }
+    // v2.6.5 T9 (H): alias drift is read from the identity doctor persisted, never re-probed here.
+    const aliasHeadlines = aliasIdentityHeadlines(cfg, health);
+    if (aliasHeadlines.length)
+        lines.push(...aliasHeadlines, "");
     const entrySeats = routingEntrySeatLines(cfg);
     if (entrySeats.length)
         lines.push(...entrySeats, "");
@@ -359,9 +392,36 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             return { line: "none — reviewPolicy judge-only: declared leaf paths", cost: 0 };
         let rotationSeat = 1;
         let rotationCount = 0;
-        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor, reviewHistory, (seat, count) => { rotationSeat = seat; rotationCount = count; });
+        // Dispatched before: no count, no single-seat claim, no previewed reviewer (and so no rotation draw this
+        // plan could name). Never a guess.
+        if (resumeDecidesAuthor(matchingEvents ?? [], task.id)) {
+            lints.push(`${task.id}: eligible cross-vendor review seat count unknown — resume state decides the author`);
+            return { line: "unknown — resume state decides the author", cost: 0 };
+        }
+        // Never dispatched, daemon.ts subjectAuthors is just the fresh author; its vendor stays off the review.
+        const authors = [channelKey(author)];
+        const authorVendors = carriedAuthorVendors(pools.review, authors);
+        // Production's inputs as the task's first review round sees them: excludeReviewers = daemon badReviewers =
+        // replayedReviewerExclusions. run-gates.ts:1303 floors on THIS task's journaled reviewers at their dispatched
+        // tiers (daemon taskReviewers) ∪ excludeReviewers, so a replayed exclusion RAISES the floor; :1305 picks
+        // with excludeReviewers ∪ retired. prefer only reorders (the seat count below passes none).
+        const priorReviewers = [...(matchingEvents ?? []).filter((e) => e.taskId === task.id && typeof e.data.reviewer === "string"
+                && ((e.event === "gate-result" && e.data.gate === "review") || e.event === "review-no-verdict"))
+                .map((e) => ({ reviewer: e.data.reviewer, tier: e.data.reviewerTier })), ...replayedReviewerExclusions];
+        const reviewFloor = gateReviewerFloor(task, cfg, author, pools.review, priorReviewers).floor;
+        const exclusions = [...replayedReviewerExclusions, ...retiredReviewers];
+        const reviewer = pickReviewer(author, pools.review, exclusions, cfg.review.prefer ?? [], reviewFloor, reviewHistory, (seat, count) => { rotationSeat = seat; rotationCount = count; }, demotedReviewers, authorVendors, authors);
         if (!reviewer)
             return { line: "none — no cross-vendor reviewer available", cost: 0 };
+        // v2.6.5 T9 (H): one flaked or demoted seat away from no reviewer. Enumerate the production filter
+        // (pickReviewer at the gate's floor) and count served identities, so two aliases of one model count once.
+        const seats = [];
+        for (let s; (s = pickReviewer(author, pools.review, [...exclusions, ...seats.map(channelKey)], [], reviewFloor, [], undefined, demotedReviewers, authorVendors, authors));)
+            seats.push(s);
+        const identities = new Set(seats.map((c) => c.identity ?? modelId(c.model)));
+        if (identities.size === 1) {
+            lints.push(`${task.id}: exactly one eligible cross-vendor review seat remains — identity ${[...identities][0]} via ${seats.map(channelKey).join(", ")}; one flake or demotion leaves no reviewer`);
+        }
         // Advance the simulated rotation only for tasks the run would actually dispatch next — the same
         // rule as readyTasks (src/graph/graph.ts): pending, with every dependency already done. A pending
         // task behind a parked/failed/pending dependency cannot run, so it consumes no draw (RULING-229-14).
@@ -402,7 +462,8 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             continue;
         }
         try {
-            const r = route(t, cfg, channels, dispatchProfile);
+            // daemon.ts:3322: the resumed run routes around its replayed worker exclusions.
+            const r = route(t, cfg, channels, dispatchProfile, undefined, demotedWorkers);
             routed.push({ taskId: t.id, adapter: r.assignment.adapter, model: r.assignment.model });
             for (const l of r.lints) {
                 const suf = exclusionReason(l);
@@ -412,7 +473,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             const judge = judgeSeat(t);
             const review = reviewSeat(t, r.assignment);
             cost += est + judge.cost + review.cost;
-            lines.push(`  ${t.id.padEnd(6)} ${t.shape.padEnd(10)} c${String(t.complexity).padEnd(3)}→ ${r.assignment.adapter}:${r.assignment.model} [${r.assignment.channel}/${r.assignment.tier}]${t.timeoutMinutes !== undefined ? ` (timeout ${t.timeoutMinutes}m)` : ""}${t.humanGate ? " (human gate)" : ""}${est ? ` ~$${est.toFixed(2)}` : ""} — ${r.provenance}`, `    judge: ${judge.line}${judge.cost ? ` ~$${judge.cost.toFixed(2)}` : ""}`, `    review: ${review.line}${review.cost ? ` ~$${review.cost.toFixed(2)}` : ""}`, chainLine(t));
+            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}`, ...[codexCommitHeadline(r.assignment.adapter, adapters, health)].filter((l) => l !== null), `    judge: ${judge.line}${judge.cost ? ` ~$${judge.cost.toFixed(2)}` : ""}`, `    review: ${review.line}${review.cost ? ` ~$${review.cost.toFixed(2)}` : ""}`, chainLine(t));
             const d = derivation(t);
             if (d)
                 lines.push(d);

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;