tickmarkr 2.6.3 → 2.6.5

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"))

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

@@ -7,7 +7,7 @@ export declare const HUMAN_AUTHOR: Assignment;
 export declare function verifyStateDir(cwd: string): string;
 /** Linked worktrees share operational state with the repository that owns the common git dir. */
 export declare function verifyStateRoot(cwd: string): Promise<string>;
-/** Cache identity is repository content, never a checkout path. */
+/** Repository content plus the effective runner inputs the daemon hashes; never a checkout path. */
 export declare function baselineCachePath(cwd: string, baseSha: string, commands: Record<string, string>): string;
 export declare function excludeAuthorProvider(channels: BillingChannel[], author: BillingChannel): BillingChannel[];
 export declare const VERIFY_HELP = "usage: tickmarkr verify [--base <ref>] [--criteria <file> | --task <id>] [--json]\nThe final verdict and JSON result are written to stdout; progress and diagnostics are written to stderr.\nDo not merge stdout and stderr (for example with 2>&1): doing so corrupts the verdict stream.";