tickmarkr 2.6.4 → 2.6.6

package/dist/tui/cockpit/board.js

@@ -136,13 +136,16 @@ export function boardFrame(input, width) {
         const unknown = buckets.filter(([, v]) => v === undefined).map(([k]) => k);
         const parked = buckets.filter(([, v]) => v !== undefined && v.length > 0).map(([k, v]) => `${k} ${v.join(",")}`);
         const tally = `${doneIds.size} merged · ${(s.buckets.human ?? []).length} parked · ${(s.buckets.blocked ?? []).length} dep-blocked`;
-        const green = !unknown.length && !parked.length && (s.currentTip === "passed" || s.currentTip === "not required");
+        // I2: the same CURRENT owed-check authority as the lifecycle — debt must be known and empty.
+        const owed = s.debt === 0 ? undefined : s.debt === "unknown" ? "outstanding unknown" : `outstanding ${s.debt} (${s.outstanding.join(", ")})`;
+        const tipOk = s.currentTip === "passed" || s.currentTip === "not required";
+        const green = !unknown.length && !parked.length && tipOk && !owed;
         const now = green
             ? `${pass("RUN ENDED — GREEN")}  ${mute(`tip ${s.currentTip} · ${tally}`)}`
             : s.currentTip === "failed"
                 ? `${fail("RUN ENDED — TIP VERIFY FAILED")}  ${mute(tally)}`
-                : parked.length || unknown.length
-                    ? `${fail("RUN ENDED — NOT GREEN")}  ${mute(`${[...parked, ...unknown.map((k) => `${k} bucket unknown`)].join(" · ")} · ${tally}`)}`
+                : parked.length || unknown.length || tipOk
+                    ? `${fail("RUN ENDED — NOT GREEN")}  ${mute(`${[...parked, ...unknown.map((k) => `${k} bucket unknown`), ...(owed ? [owed] : [])].join(" · ")} · ${tally}`)}`
                     : `${warn("RUN ENDED — TIP NOT VERIFIED")}  ${mute(`tip ${s.currentTip} · ${tally}`)}`;
         top.push(`  ${accent("▌")} ${bold("NOW")}        ${now}`);
         top.push("");
@@ -152,8 +155,11 @@ export function boardFrame(input, width) {
     top.push("");
     // ── aligned gate header: each label truncated to the cell it owns (prototype :382-394) ──
     const elastic = Math.max(30, W - BOARD_FIXED - BOARD_NOTE_RESERVE);
-    const LBL = Math.min(46, Math.max(18, Math.round(elastic * 0.62)));
-    const CHAN = Math.min(26, Math.max(12, elastic - LBL));
+    const compactLabel = Math.min(46, Math.max(18, Math.round(elastic * 0.62)));
+    const stacked = boardBand(W) === "stacked";
+    const LBL = stacked ? Math.max(0, W - 4 - 5 - BOARD_AREA_W - BOARD_DEPS_W)
+        : compactLabel;
+    const CHAN = Math.min(26, Math.max(12, elastic - compactLabel));
     const gateHead = BOARD_GATES.map((g) => faint(pad(g.slice(0, BOARD_CELL - 1), BOARD_CELL))).join("");
     const gateHeader = {
         head: `    ${pad("", 5)}${pad(faint("area"), BOARD_AREA_W)}${pad(faint("deps"), BOARD_DEPS_W)}${pad(faint("task"), LBL)}`,
@@ -200,7 +206,7 @@ export function boardFrame(input, width) {
             ? depText
             : depIds.length > 1 ? `${depIds[0]}+${depIds.length - 1}` : `${depIds[0].slice(0, BOARD_DEPS_W - 3)}…`;
         const deps = pad(faint(depLabel), BOARD_DEPS_W);
-        const titleText = sliceCells(g.title ?? "", LBL - 2).head;
+        const titleText = sliceCells(g.title ?? "", stacked ? LBL : LBL - 2).head;
         const title = hot ? body(pad(titleText, LBL)) : faint(pad(titleText, LBL));
         const note = [
             parks >= 3 ? park(`◍ parked ×${parks}`) : "",

package/dist/tui/cockpit/keys.d.ts

@@ -259,6 +259,10 @@ export declare const SHELL_BINDINGS: readonly [{
     readonly key: "5";
     readonly label: "Evidence";
     readonly action: "evidence";
+}, {
+    readonly key: "7";
+    readonly label: "Log";
+    readonly action: "log";
 }, {
     readonly key: "Tab";
     readonly label: "Focus";
@@ -322,6 +326,10 @@ export declare function shellBindings(context: {
     readonly key: "5";
     readonly label: "Evidence";
     readonly action: "evidence";
+} | {
+    readonly key: "7";
+    readonly label: "Log";
+    readonly action: "log";
 } | {
     readonly key: "Tab";
     readonly label: "Focus";

package/dist/tui/cockpit/keys.js

@@ -637,6 +637,7 @@ export const SHELL_BINDINGS = [
     { key: "1", label: "Home", action: "home" },
     { key: "4", label: "Run", action: "run" },
     { key: "5", label: "Evidence", action: "evidence" },
+    { key: "7", label: "Log", action: "log" },
     { key: "Tab", label: "Focus", action: "focus" },
     { key: "Enter", label: "Open", action: "open" },
     { key: "a", label: "Actions", action: "actions" },
@@ -658,7 +659,9 @@ export function shellBindings(context) {
             return context.canResize === true;
         if (binding.action === "export")
             return context.view === "evidence";
-        if (binding.action === "filter" || binding.action === "follow")
+        if (binding.action === "follow")
+            return context.view === "log" || context.view === "evidence" && !context.evidenceSection;
+        if (binding.action === "filter")
             return context.view === "evidence" && !context.evidenceSection;
         return true;
     });

package/dist/tui/cockpit/layout.d.ts

@@ -306,8 +306,8 @@ export declare function planFrame(size: MeasuredSize, view?: FrameView, state?:
 export declare function resolveCockpitLayout(columns: number, rows: number): CockpitLayout;
 /**
  * FINAL §3.1: one geometry for paint, focus and pointer hit testing. A ZERO shortcut budget is the
- * rail-less mount (BD-1, RULING-231-19 §2): the daemon-placed board is a one-view observer, so it
- * plans no rail and no shortcuts at any width — the budget is honoured, never floored back to 20.
+ * explicit compact mount: it plans no rail and no shortcuts at any width. Daemon-owned and manual
+ * boards both use the default budget; an explicit zero is honoured, never floored back to 20.
  */
 export declare function planShell(columns: number, rows: number, shortcutColumns?: number): {
     columns: number;

package/dist/tui/cockpit/layout.js

@@ -391,8 +391,8 @@ export function resolveCockpitLayout(columns, rows) {
 }
 /**
  * FINAL §3.1: one geometry for paint, focus and pointer hit testing. A ZERO shortcut budget is the
- * rail-less mount (BD-1, RULING-231-19 §2): the daemon-placed board is a one-view observer, so it
- * plans no rail and no shortcuts at any width — the budget is honoured, never floored back to 20.
+ * explicit compact mount: it plans no rail and no shortcuts at any width. Daemon-owned and manual
+ * boards both use the default budget; an explicit zero is honoured, never floored back to 20.
  */
 export function planShell(columns, rows, shortcutColumns = 22) {
     columns = Math.max(0, Math.floor(columns));

package/dist/tui/cockpit/live-runtime.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { renderMarkdownRecord } from "../../cli/commands/report.js";
 import { loadConfig } from "../../config/config.js";
@@ -7,13 +7,14 @@ import { estimateCosts } from "../../report/cost.js";
 import { PerformanceObserver, performance } from "node:perf_hooks";
 import { render, useInput, useStdin } from "ink";
 import { useLayoutEffect, useSyncExternalStore } from "react";
-import { createLiveStore } from "./live-store.js";
+import { createLiveStore, journalBasis, readObservedJournal } from "./live-store.js";
 import { HomeView, deriveHomeView, selectNeedsYouTarget } from "./home-view.js";
 import { RunView, applyRunViewKey, initialRunViewSession, runGateCells, evidenceLookup } from "./run-view.js";
 import { renderBoardLines, stripBoardAnsi } from "./board.js";
 import { EvidenceView, deriveEvidenceView, defaultExportPath, planEvidenceExport, writeEvidenceExport } from "./evidence-view.js";
 import { ShellGridFlow, ShellJournalSelection } from "./components.js";
 import { CockpitShell, initialShellState } from "./shell.js";
+import { LogView, readLogPage, moveLogEnd } from "./log-view.js";
 import { planShell } from "./layout.js";
 import { shellBindings } from "./keys.js";
 import { createPointerReportReader, POINTER_TRACKING_ON, POINTER_TRACKING_OFF } from "./pointer.js";
@@ -21,7 +22,7 @@ import { deriveRunDecisions, previewDecision, executeDecision, withDecisionPrevi
 import { approvalRunOwner } from "../../cli/commands/approve.js";
 import { GLYPHS } from "../../brand.js";
 import { effectiveEvents, Journal, parseJournalText, physicalLine } from "../../run/journal.js";
-import { observeNamedRun, WATCH_OWNER_ENV } from "../../run/supervision.js";
+import { observeNamedRun } from "../../run/supervision.js";
 import { formatOwnedName } from "../../drivers/types.js";
 import { readOperatorState } from "../../run/operator-state.js";
 import { cellWidth, wrapCells } from "./width.js";
@@ -59,6 +60,10 @@ export function borrowRuntimeTimeline() {
 }
 export const SHELL_TERMINAL_ENTER = "\x1b[?1049h\x1b[22;0t\x1b]0;tickmarkr cockpit\x07" + POINTER_TRACKING_ON;
 export const SHELL_TERMINAL_RESTORE = POINTER_TRACKING_OFF + "\x1b[23;0t\x1b[?25h\x1b[?1049l";
+/** Rows not bound to the store's observation: only the store's own observation is served, with debt unknown
+ * (the fold's formula then gives PARTIAL for a headline that was green — green implies ended and unapproved). */
+const unbound = (snap) => ({ ...snap, owed: undefined, operator: { ...snap.operator, debt: "unknown", outstanding: [],
+        green: false, ...(snap.operator.green ? { lifecycle: "PARTIAL", label: "PARTIAL" } : {}) } });
 /**
  * OBS-1178: the store's incremental fold reads every task-approved row as a release. A refused or unsound
  * decision released nothing, so whenever the rows the store has read hold one — whatever state the raw
@@ -70,36 +75,48 @@ export const SHELL_TERMINAL_RESTORE = POINTER_TRACKING_OFF + "\x1b[23;0t\x1b[?25
  */
 export function decidedLiveStore(store) {
     let key;
-    let operator;
+    let events;
+    // I2: the refold is keyed by the store's owed authority too, so a debt the store re-folded (an artifact
+    // removed or altered under unchanged journal bytes) is never served from an earlier observation's refold.
+    let folded;
     const decided = (snap) => {
         const { journal, graph } = snap;
-        const observed = `${journal.source}:${journal.generation}:${journal.offset}:${graph.identity}:${graph.status}`;
+        const observed = `${journalBasis(journal)}:${graph.identity}:${graph.status}:${snap.lock.state}`;
         if (observed !== key) {
             key = observed;
-            operator = undefined;
+            events = undefined;
+            folded = undefined;
             let bytes;
+            // I2 (D-857): the refold reads the very journal version the store observed — the one its owed authority
+            // and basis name. A changed or failed read is never cached (un-keyed, re-read next observation) and
+            // decides nothing meanwhile: debt unknown, never green.
             try {
-                bytes = readFileSync(journal.source).subarray(0, journal.offset);
+                bytes = readObservedJournal(journal);
             }
             catch {
-                return snap;
+                key = undefined;
+                return unbound(snap);
             }
             if (bytes.includes("task-approved")) {
                 const rows = parseJournalText(bytes.subarray(0, bytes.lastIndexOf(10) + 1).toString("utf8"))
                     .filter(e => e !== null && typeof e === "object" && typeof e.event === "string" && typeof e.data === "object" && e.data !== null);
                 const kept = effectiveEvents(rows);
                 if (kept.length !== rows.length) {
-                    const events = kept.map((event, i) => {
+                    events = kept.map((event, i) => {
                         const line = physicalLine(kept, i);
                         return { source: journal.source, line, id: `${journal.source}#L${line}`, generation: journal.generation, event };
                     });
-                    operator = readOperatorState({ events, graph: graph.status === "readable" ? graph.value : undefined,
-                        readable: journal.status === "readable" && journal.backlogBytes === 0 });
                 }
             }
         }
-        if (!operator)
+        if (!events)
             return snap;
+        if (!folded || folded.owed !== snap.owed) {
+            folded = { owed: snap.owed, operator: readOperatorState({ events, graph: graph.status === "readable" ? graph.value : undefined,
+                    readable: journal.status === "readable" && journal.backlogBytes === 0, daemonDead: snap.lock.state === "dead",
+                    owed: snap.owed, basis: journalBasis(journal) }) };
+        }
+        const operator = folded.operator;
         const { sequence, observedAt, graphAvailability } = snap.operator;
         return { ...snap, operator: { ...operator, sequence, observedAt, graphAvailability } };
     };
@@ -147,10 +164,8 @@ export async function runConsolidatedCockpit(options) {
         const source = decidedLiveStore(store);
         if (options.observeRun !== false)
             observation = observeNamedRun(cwd, runId, options.environment);
-        // BD-1 (RULING-231-19 §2): the daemon-placed board carries the watch owner token and mounts
-        // rail-less — a zero shortcut budget the plan honours at every width. The manual cockpit keeps its rail.
-        const railless = Boolean((options.environment ?? process.env)[WATCH_OWNER_ENV]);
-        let state = { ...initialShellState(), view: options.initialView ?? "home", ...(railless ? { shortcutColumns: 0 } : {}) };
+        // Daemon-placed and manual boards share the same rails and navigation.
+        let state = { ...initialShellState(), view: options.initialView ?? "home" };
         let runSession = initialRunViewSession();
         if (options.initialParks) {
             runSession = { ...runSession, selection: Math.max(0, source.snapshot().operator.tasks.findIndex(t => t.state === "human" || t.state === "blocked")) };
@@ -202,6 +217,9 @@ export async function runConsolidatedCockpit(options) {
                 snap.journal.generation, snap.journal.offset, snap.journal.status, snap.journal.malformedCount, snap.journal.backlogBytes, snap.journal.pending, snap.journal.error,
                 snap.graph.identity, snap.graph.status, snap.config.identity, snap.config.status, snap.cache.identity, snap.cache.status,
                 snap.lock.value, snap.lock.status, snap.lock.state, snap.lock.alive,
+                // I2: owed-check debt moves under unchanged journal bytes (an artifact removed or altered) and
+                // decides the drawn lifecycle and board headline.
+                snap.operator.lifecycle, snap.operator.debt, snap.operator.outstanding,
                 // D-383: supervision tier state is not drawn by any view; an ARMED→STALE transition earns no
                 // frame. Its UNREADABLE case already surfaces through snap.errors above.
             ]);
@@ -418,7 +436,7 @@ export async function runConsolidatedCockpit(options) {
             }
             else {
                 const action = shellBindings(state).find(b => b.key === text)?.action;
-                if (action === "home" || action === "run" || action === "evidence")
+                if (action === "home" || action === "run" || action === "evidence" || action === "log")
                     state = { ...state, view: action, scroll: 0, evidenceSection: action === state.view ? state.evidenceSection : 0 };
                 else if (action === "widen" || action === "narrow")
                     state = { ...state, shortcutColumns: planShell(geometry().columns, geometry().rows, geometry().shortcuts + (action === "widen" ? 1 : -1)).shortcuts };
@@ -432,6 +450,13 @@ export async function runConsolidatedCockpit(options) {
                 }
                 else if (state.view === "evidence" && (k.leftArrow || k.rightArrow))
                     state = { ...state, evidenceSection: ((state.evidenceSection ?? 0) + (k.rightArrow ? 1 : 4)) % 5 };
+                else if (state.view === "log" && (k.pageDown || k.pageUp || k.upArrow || k.downArrow || action === "follow")) {
+                    const snap = source.snapshot();
+                    const sourceLog = { journal: snap.journal, page: source.page, runId, columns: geometry().bodyColumns };
+                    const delta = (k.pageDown || k.downArrow ? 1 : -1) * (k.pageDown || k.pageUp ? geometry().bodyRows : 1);
+                    state = { ...state, logEnd: action === "follow" ? state.logEnd === undefined ? snap.journal.lines : undefined
+                            : moveLogEnd(sourceLog, state.logEnd, delta), scroll: 0 };
+                }
                 else if ((k.pageDown || k.pageUp) && state.view !== "run")
                     state = { ...state, scroll: Math.max(0, state.scroll + (k.pageDown ? 1 : -1) * geometry().bodyRows) };
                 else if (k.return || action === "open") {
@@ -471,7 +496,7 @@ export async function runConsolidatedCockpit(options) {
                 else if (text === "a")
                     state = { ...state, overlay: ["Existing CLI actions", "tickmarkr fleet", "tickmarkr plan", "tickmarkr doctor"], overlayOffset: 0 };
             }
-            if (!terminal && state.view !== "run" && !state.overlay && !state.help && state.editor === undefined) {
+            if (!terminal && state.view !== "run" && state.view !== "log" && !state.overlay && !state.help && state.editor === undefined) {
                 const bytes = k.upArrow ? "\x1b[A" : k.downArrow ? "\x1b[B" : k.rightArrow ? "\x1b[C" : k.leftArrow ? "\x1b[D" : k.pageUp ? "\x1b[5~" : k.pageDown ? "\x1b[6~" : text === "f" ? "f" : undefined;
                 if (bytes)
                     forwardLeaf(bytes);
@@ -700,7 +725,7 @@ export async function runConsolidatedCockpit(options) {
                     const usedTasks = new Set();
                     for (const row of plan.paintedRows) {
                         if (row.row < plan.bodyRow && (row.text.startsWith("1 Home") || row.text.startsWith("1H"))) {
-                            for (const binding of bindings.filter(binding => ["home", "run", "evidence"].includes(binding.action))) {
+                            for (const binding of bindings.filter(binding => ["home", "run", "evidence", "log"].includes(binding.action))) {
                                 const caption = plan.columns < 60 ? `${binding.key}${binding.label[0]}` : `${binding.key} ${binding.label}`;
                                 const index = row.text.indexOf(caption);
                                 if (index >= 0)
@@ -758,7 +783,8 @@ export async function runConsolidatedCockpit(options) {
                     committedTargets = targets;
                 }, children: state.view === "home" ? _jsx(ShellGridFlow, { width: p.bodyColumns, columns: p.columns < 120 ? 2 : 3, rowHeight: p.rows < 20 ? 1 : p.columns < 120 ? 2 : 3, children: _jsx(HomeView, { width: p.bodyColumns, model: homeModel, focused: focused, onOpenPark: id => { runSession = { ...runSession, selection: Math.max(0, snap.operator.tasks.findIndex(t => t.id === id)) }; state = { ...state, view: "run", scroll: 0 }; followSelection(); publish(); }, onOpenDiagnostic: id => { state = { ...state, overlay: [id], overlayOffset: 0 }; publish(); }, onOpenEvidence: openEvidence, onSelectNeedsYou: reportHomeNeedsYouSelection }, String(homeModel.needsYou.length > 0)) }) :
                     state.view === "run" ? _jsx(RunView, { snapshot: snap.operator, rows: snap.journal.history, page: source.page, graph: snap.graph.value, decisions: visibleDecisions, session: runSession, columns: p.bodyColumns, run: approvalRunOwner(cwd, runId), now: options.now }) :
-                        _jsx(ShellJournalSelection.Provider, { value: reportEvidenceSelection, children: _jsx(EvidenceView, { width: p.bodyColumns, model: { ...model, journal: evidenceRows }, focusEvidence: selectedEvidence, focused: focused, onExport: beginExport, onSelect: id => { selectedEvidence = id; openDetail(); publish(); } }, `${state.query}:${evidenceNavigation}`) }) });
+                        state.view === "log" ? _jsx(LogView, { page: readLogPage({ journal: snap.journal, page: source.page, runId, columns: p.bodyColumns }, p.bodyRows, state.logEnd) }) :
+                            _jsx(ShellJournalSelection.Provider, { value: reportEvidenceSelection, children: _jsx(EvidenceView, { width: p.bodyColumns, model: { ...model, journal: evidenceRows }, focusEvidence: selectedEvidence, focused: focused, onExport: beginExport, onSelect: id => { selectedEvidence = id; openDetail(); publish(); } }, `${state.query}:${evidenceNavigation}`) }) });
         }
         app = render(_jsx(App, {}), { stdin, stdout: output, debug: options.debug, exitOnCtrlC: false, patchConsole: false });
         void app.waitUntilExit().then(() => stop(), stop);

package/dist/tui/cockpit/live-store.d.ts

@@ -1,5 +1,5 @@
 import { type JournalEvent } from "../../run/journal.js";
-import { type OperatorRecord } from "../../run/operator-state.js";
+import { type OperatorRecord, type OwedAuthority } from "../../run/operator-state.js";
 export declare const OBSERVATION_INTERVAL_MS = 1000;
 /** Stat-to-fstat observations one poll spends on a journal a writer keeps appending to. */
 export declare const APPEND_RACE_OBSERVATIONS = 3;
@@ -27,9 +27,12 @@ export interface JournalLine extends Omit<OperatorRecord, "event"> {
     endOffset: number;
 }
 export interface TailSnapshot {
+    /** `digest` (I2): sha256 of every byte the tail consumed, [0, offset) — the bytes its fold was built from. */
     source: string;
     generation: number;
     identity?: string;
+    version?: string;
+    digest: string;
     offset: number;
     lines: number;
     history: readonly JournalLine[];
@@ -64,11 +67,17 @@ export declare class JournalTail {
     private lastSuccessfulReadAt?;
     private failure?;
     private stale;
+    private hash;
+    private invalid;
     constructor(source: string, hooks?: {
         record?: (record: OperatorRecord) => void;
         reset?: () => void;
     });
     private reset;
+    /** I2: the consumed prefix was found rewritten (an in-place rewrite then growth reads as an append), so the
+     * next poll treats the file as replaced and refolds it from its first byte. */
+    invalidate(): void;
+    get invalidated(): boolean;
     /** A same-inode append between stat and fstat is retried; exhaustion keeps the last good snapshot, pending. */
     poll(now?: number): TailSnapshot;
     /** One stat-to-fstat observation. False when an append raced it; nothing was consumed or reset. */
@@ -86,6 +95,18 @@ export interface CachedSource<T = unknown> {
     error?: string;
     observedAt: number;
 }
+/** I2: the journal basis an owed-check fold read — the observed file version, its generation and the bytes consumed. */
+export declare const journalBasis: (journal: TailSnapshot) => string;
+/** I2: the bytes the tail consumed are no longer the file's prefix — rewritten in place, then grown. */
+export declare class JournalRewritten extends Error {
+    constructor();
+}
+/** I2 (D-857): the ONE way any reader beside the tail gets `journal`'s bytes — every consumed byte of the very
+ * file version the tail observed (an in-place rewrite, even an equal-length one, changes it), stamped before
+ * and after the read, and proved by digest to be the very bytes the tail's fold consumed (a rewrite followed by
+ * growth keeps the tail appending). Any change throws, so no second read is ever combined with this
+ * observation's lifecycle, owed or basis. */
+export declare function readObservedJournal(journal: TailSnapshot): Buffer;
 export interface LiveStoreOptions {
     cwd: string;
     runId: string;
@@ -102,6 +123,7 @@ export declare function createLiveStore(options: LiveStoreOptions): {
         delayed: boolean;
         freshness: string;
         operator: import("../../run/operator-state.js").OperatorSnapshot;
+        owed: OwedAuthority | undefined;
         journal: TailSnapshot;
         graph: CachedSource<{
             version: 1;
@@ -204,6 +226,7 @@ export declare function createLiveStore(options: LiveStoreOptions): {
         delayed: boolean;
         freshness: string;
         operator: import("../../run/operator-state.js").OperatorSnapshot;
+        owed: OwedAuthority | undefined;
         journal: TailSnapshot;
         graph: CachedSource<{
             version: 1;

package/dist/tui/cockpit/live-store.js

@@ -1,8 +1,9 @@
+import { createHash } from "node:crypto";
 import { closeSync, fstatSync, openSync, readSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { graphPath, stateDirName } from "../../graph/graph.js";
 import { validateGraph } from "../../graph/schema.js";
-import { parseRunId } from "../../run/journal.js";
+import { foldOwedChecks, parseJournalText, parseRunId } from "../../run/journal.js";
 import { isPidLive, STALE_MS } from "../../run/lock.js";
 import { readTierLiveness, SUPERVISION_TIERS } from "../../run/supervision.js";
 import { OperatorStateFold } from "../../run/operator-state.js";
@@ -14,6 +15,12 @@ export const STORE_LIMITS = { graphBytes: 16 * 1024 * 1024, history: 256, histor
 const errorText = (e) => e instanceof Error ? e.message : String(e);
 const fileIdentity = (st) => `${st.dev}:${st.ino}`;
 const stamp = (st) => `${fileIdentity(st)}:${st.size}:${st.mtimeNs}:${st.ctimeNs}`;
+/** The one record shape the tail accepts; the complete-journal (owed) read validates against it too. */
+const isJournalRecord = (e) => {
+    const r = e;
+    return !!r && typeof r === "object" && typeof r.ts === "string" && Number.isFinite(Date.parse(r.ts)) && typeof r.event === "string"
+        && !!r.data && typeof r.data === "object" && !Array.isArray(r.data) && (r.taskId === undefined || typeof r.taskId === "string");
+};
 function decodeLine(bytes, source, line, offset, endOffset, generation, oversized = false) {
     const base = { source, line, id: `${source}#L${line}`, offset, endOffset, generation };
     let raw = "";
@@ -24,7 +31,7 @@ function decodeLine(bytes, source, line, offset, endOffset, generation, oversize
         if (!raw.trim())
             return { ...base, raw };
         const e = JSON.parse(raw);
-        if (!e || typeof e !== "object" || typeof e.ts !== "string" || !Number.isFinite(Date.parse(e.ts)) || typeof e.event !== "string" || !e.data || typeof e.data !== "object" || Array.isArray(e.data) || (e.taskId !== undefined && typeof e.taskId !== "string"))
+        if (!isJournalRecord(e))
             throw new Error("invalid journal record");
         return { ...base, raw, event: e };
     }
@@ -51,6 +58,8 @@ export class JournalTail {
     lastSuccessfulReadAt;
     failure;
     stale = false;
+    hash = createHash("sha256");
+    invalid = false;
     constructor(source, hooks = {}) {
         this.source = source;
         this.hooks = hooks;
@@ -66,8 +75,14 @@ export class JournalTail {
         this.errors = [];
         this.malformedCount = 0;
         this.generation++;
+        this.hash = createHash("sha256");
+        this.invalid = false;
         this.hooks.reset?.();
     }
+    /** I2: the consumed prefix was found rewritten (an in-place rewrite then growth reads as an append), so the
+     * next poll treats the file as replaced and refolds it from its first byte. */
+    invalidate() { this.invalid = true; }
+    get invalidated() { return this.invalid; }
     /** A same-inode append between stat and fstat is retried; exhaustion keeps the last good snapshot, pending. */
     poll(now = Date.now()) {
         try {
@@ -94,7 +109,7 @@ export class JournalTail {
             const st = statSync(this.source, { bigint: true });
             if (!st.isFile())
                 throw new Error("journal source is not a regular file");
-            const replaced = !this.st || fileIdentity(st) !== fileIdentity(this.st) || st.size < this.st.size || (st.size === this.st.size && stamp(st) !== stamp(this.st));
+            const replaced = this.invalid || !this.st || fileIdentity(st) !== fileIdentity(this.st) || st.size < this.st.size || (st.size === this.st.size && stamp(st) !== stamp(this.st));
             if (Number(st.size) > (replaced ? 0 : this.offset)) {
                 fd = openSync(this.source, "r");
                 const opened = fstatSync(fd, { bigint: true });
@@ -115,6 +130,7 @@ export class JournalTail {
                         throw new Error("journal truncated during read");
                     this.bytesRead += count;
                     remaining -= count;
+                    this.hash.update(buffer.subarray(0, count));
                     let begin = 0;
                     for (let index = 0; index < count; index++)
                         if (buffer[index] === 10) {
@@ -158,7 +174,7 @@ export class JournalTail {
     }
     snapshot() {
         return {
-            source: this.source, generation: this.generation, identity: this.st && fileIdentity(this.st), offset: this.offset, lines: this.line,
+            source: this.source, generation: this.generation, identity: this.st && fileIdentity(this.st), version: this.st && stamp(this.st), digest: this.hash.copy().digest("hex"), offset: this.offset, lines: this.line,
             history: this.history.slice(), errors: this.errors.slice(), malformedCount: this.malformedCount,
             pending: this.carryBytes ? { line: this.line + 1, bytes: this.carryBytes } : undefined,
             backlogBytes: Math.max(0, Number(this.st?.size ?? 0) - this.offset),
@@ -262,6 +278,48 @@ class JsonSource {
         }
     }
 }
+/** I2: the journal basis an owed-check fold read — the observed file version, its generation and the bytes consumed. */
+export const journalBasis = (journal) => `${journal.source}:${journal.generation}:${journal.version}:${journal.offset}`;
+const unknownOwed = (reason) => ({ known: false, debt: "unknown", outstanding: [], acceptedRisk: [], discharged: [], unknown: [{ reason }] });
+/** I2: the bytes the tail consumed are no longer the file's prefix — rewritten in place, then grown. */
+export class JournalRewritten extends Error {
+    constructor() { super("journal prefix rewritten since the tail consumed it"); }
+}
+/** I2 (D-857): the ONE way any reader beside the tail gets `journal`'s bytes — every consumed byte of the very
+ * file version the tail observed (an in-place rewrite, even an equal-length one, changes it), stamped before
+ * and after the read, and proved by digest to be the very bytes the tail's fold consumed (a rewrite followed by
+ * growth keeps the tail appending). Any change throws, so no second read is ever combined with this
+ * observation's lifecycle, owed or basis. */
+export function readObservedJournal(journal) {
+    const fd = openSync(journal.source, "r");
+    try {
+        const observed = () => { if (stamp(fstatSync(fd, { bigint: true })) !== journal.version)
+            throw new Error("journal changed since its observation"); };
+        observed();
+        const bytes = Buffer.alloc(journal.offset);
+        for (let length = 0; length < bytes.length;) {
+            const n = readSync(fd, bytes, length, bytes.length - length, length);
+            if (!n)
+                throw new Error("journal truncated since its observation");
+            length += n;
+        }
+        observed();
+        if (createHash("sha256").update(bytes).digest("hex") !== journal.digest)
+            throw new JournalRewritten();
+        return bytes;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** The complete journal behind `journal`'s basis: its observed bytes, every non-blank line a valid record. */
+function readLedger(journal) {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(readObservedJournal(journal));
+    const events = parseJournalText(text);
+    if (events.length !== text.split("\n").filter(line => line.trim()).length || !events.every(isJournalRecord))
+        throw new Error("complete journal holds an invalid line");
+    return events;
+}
 /** C1 mount/C6 reader boundary. No timers or presence writes: the mount owns scheduling and disarm. */
 export function createLiveStore(options) {
     const now = options.now ?? Date.now;
@@ -285,10 +343,41 @@ export function createLiveStore(options) {
     let disposed = false;
     let queued;
     const metrics = [];
+    // I2: the complete journal is re-read only when its basis moves; its owed fold re-reads every discharge
+    // artifact on every observation, and only the immutable git re-proof is reused through this store's memo.
+    // ponytail: an ended run's whole parsed journal stays resident; fold a debt-only projection if that measures large.
+    const owedMemo = new Set();
+    let ledger;
+    const owedAuthority = (journal) => {
+        const basis = journalBasis(journal);
+        if (ledger?.basis !== basis) {
+            // Never cache a failure: only a successful read is reused; a failed one is unknown debt now and re-read next observation.
+            try {
+                ledger = { basis, events: readLedger(journal) };
+            }
+            catch (e) {
+                ledger = undefined;
+                if (e instanceof JournalRewritten)
+                    tail.invalidate();
+                return { basis, fold: unknownOwed(`complete journal unreadable: ${errorText(e)}`) };
+            }
+        }
+        return { basis, fold: foldOwedChecks(ledger.events, options.cwd, owedMemo) };
+    };
     function observe() {
         const observedAt = now();
         const delayed = lastObservation !== undefined && observedAt - lastObservation > 2 * OBSERVATION_INTERVAL_MS;
-        const journal = tail.poll(observedAt);
+        const isReadable = (j) => j.status === "readable" && j.backlogBytes === 0;
+        // Debt decides only an ended run's headline; a running or unreadable journal never pays for the fold.
+        const owedOf = (j) => isReadable(j) && fold.ended ? owedAuthority(j) : undefined;
+        let journal = tail.poll(observedAt);
+        let owed = owedOf(journal);
+        // I2: the owed read found the tail's consumed prefix rewritten, so its fold (lifecycle) is stale. Refold the
+        // whole file now: lifecycle and debt then come from the same bytes. A repeat rewrite is unknown debt.
+        if (tail.invalidated) {
+            journal = tail.poll(observedAt);
+            owed = owedOf(journal);
+        }
         const graphReading = graph.read(observedAt);
         const configReading = config.read(observedAt);
         const cacheReading = cache.read(observedAt);
@@ -301,11 +390,13 @@ export function createLiveStore(options) {
         if (metrics.length > STORE_LIMITS.metrics)
             metrics.shift();
         lastObservation = observedAt;
-        const readable = journal.status === "readable" && journal.backlogBytes === 0;
+        const readable = isReadable(journal);
         return {
             sequence: ++sequence, observedAt, delayed, freshness: errors.length ? "failed" : delayed ? "delayed" : "fresh",
-            operator: fold.snapshot({ graph: graphReading.status === "readable" ? graphReading.value : undefined, sequence, observedAt, readable, graphAvailability: { status: graphReading.status, error: graphReading.error } }),
-            journal, graph: graphReading, config: configReading, cache: cacheReading,
+            // I1: only this run's own lock naming a provably-dead (ESRCH) holder settles unfinished cells; an alive,
+            // EPERM, foreign, unreadable or absent lock is not proof the work stopped.
+            operator: fold.snapshot({ graph: graphReading.status === "readable" ? graphReading.value : undefined, sequence, observedAt, readable, graphAvailability: { status: graphReading.status, error: graphReading.error }, daemonDead: lockState === "dead", owed, basis: journalBasis(journal) }),
+            owed, journal, graph: graphReading, config: configReading, cache: cacheReading,
             lock: { ...owner, state: lockState, alive, expired: owner.identity ? observedAt - Number(owner.identity.split(":")[3]) / 1e6 > STALE_MS : undefined },
             supervision, errors, actionsEnabled: readable && !errors.length && !delayed,
             viewport, inputSequence, metrics: metrics.slice(),

package/dist/tui/cockpit/log-view.d.ts

@@ -0,0 +1,28 @@
+import type { JournalEvent } from "../../run/journal.js";
+import { type JournalLine, type TailSnapshot } from "./live-store.js";
+/** The board uses the daemon's TTY narration, including its suppression and sanitization. */
+export declare const renderLogLines: (events: readonly JournalEvent[], runId: string, columns: number) => string[];
+export interface LogRow {
+    line: number;
+    text: string;
+}
+export interface LogPage {
+    rows: readonly LogRow[];
+    error?: string;
+}
+type PageReader = (firstLine: number, count?: number, generation?: number) => readonly JournalLine[];
+interface LogSource {
+    journal: TailSnapshot;
+    page: PageReader;
+    runId: string;
+    columns: number;
+}
+/** Demand-page backwards to fill the viewport, including events outside the store's retained tail.
+ * Only the requested visible rows survive; suppressed events never consume viewport rows. */
+export declare function readLogPage(source: LogSource, count: number, end?: number): LogPage;
+/** Move by visible narration rows. Undefined means follow the journal tail again. */
+export declare function moveLogEnd(source: LogSource, end: number | undefined, delta: number): number | undefined;
+export declare function LogView({ page }: {
+    page: LogPage;
+}): import("react").JSX.Element;
+export {};