tickmarkr 1.84.0 → 1.86.0

package/dist/run/stall.js

@@ -18,6 +18,62 @@ const ELAPSED_RE = /(?<![\w.])\d+(?:\.\d+)?(?:ms|[hms])(?!\w)/g;
 export function normalizeStallSnapshot(text) {
     return text.replace(ANSI_RE, "").replace(SPINNER_RE, "").replace(ELAPSED_RE, "");
 }
+// T1 (OBS-262): the rescue nudge's adapter scope — claude-code only (steering path proven,
+// OBS-122). Widening it is a future fixture-capture chore (an occupied-frame capture per adapter,
+// OBS-181 scar), never a drive-by edit. Lives in the stall module so the watchdog's policy and its
+// scope constant cannot drift apart.
+export const NUDGEABLE_ADAPTERS = new Set(["claude-code"]);
+// T1 (OBS-263): a LIVE provider banner is the last thing the pane printed — the worker stopped
+// underneath it. A "quota"/"rate limit" mention inside the task prompt, a diff hunk, or earlier
+// output sits ABOVE the transcript tail and must never fail an attempt over, so the in-loop quota
+// classifier reads only this many trailing non-empty rows instead of the whole retained snapshot.
+// ponytail: rows, not a banner grammar — the ceiling is a worker frozen with a quota mention as its
+// literal last output; the two-consecutive-slices + tracker-silence gates bound that cost to one
+// failover within the routing floor. Upgrade path is a per-adapter banner fixture if it ever bites.
+export const QUOTA_BANNER_TAIL_ROWS = 12;
+export function stallSnapshotTail(text, rows = QUOTA_BANNER_TAIL_ROWS) {
+    return normalizeStallSnapshot(text)
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .slice(-rows)
+        .join("\n");
+}
+// T1 review (chrome-blind-matcher class, OBS-152/155): the tail of a RENDERED TUI frame is not
+// "what the pane printed last" — its bottom rows are fixed composer/welcome chrome. Codex pins
+// "• You have 3 usage limit resets available." there, so a raw-tail QUOTA_RE match fires on every
+// frame of a wedged pane (verified against all 8 frames of tests/fixtures/codex-mcp-spinner) and
+// would fail a live worker over mid-work. Filter the KNOWN chrome instead of everything on screen
+// at some anchor: a novelty baseline cannot distinguish "chrome that was already there" from "a
+// real banner the CLI printed before the first poll read" — a channel throttled at launch paints
+// its banner inside the first BLOCKED_POLL_MS slice, so the banner BECOMES the baseline and is
+// exculpated forever (proven by execution: banner-from-the-first-loop-read fails over on shipped
+// 843328b0, parks human under the baseline). This line is semantically the opposite of exhaustion
+// — resets AVAILABLE — so matching it out can never hide a real banner. Closed allowlist, same
+// philosophy as the normalizer's: a new adapter's quota-flavored chrome is a fixture-capture
+// chore, never a drive-by edit.
+const QUOTA_CHROME_RE = /usage limit resets? available/i;
+export function stallSnapshotBannerRows(text, rows = QUOTA_BANNER_TAIL_ROWS) {
+    return stallSnapshotTail(text, rows)
+        .split("\n")
+        .filter((line) => !QUOTA_CHROME_RE.test(line))
+        .join("\n");
+}
+// T1 (OBS-262/263, speed-spec §2): past fifteen minutes with a FLAT token-usage counter, row
+// growth alone no longer re-arms the inactivity window — cosmetic repaint rows are not paid work.
+// Token usage is the paid-work signal the tracker already samples; token growth always re-arms.
+export const ROW_REARM_TOKEN_FLAT_MS = 15 * 60_000;
+// Test seam, same pattern as the daemon's timing seams: production reads the constant.
+let rowRearmTokenFlatMs = ROW_REARM_TOKEN_FLAT_MS;
+export function setRowRearmTokenFlatMsForTests(ms) {
+    rowRearmTokenFlatMs = ms;
+}
+export function resetRowRearmTokenFlatMsForTests() {
+    rowRearmTokenFlatMs = ROW_REARM_TOKEN_FLAT_MS;
+}
+// T1 review (read-ceiling blindness): the daemon samples panes through `driver.read(slot, N)` —
+// a bounded window. This constant IS that N, and the daemon's pane reads must use it (never a
+// literal) so the tracker's saturation check below cannot drift away from the real read depth.
+export const PANE_READ_ROWS = 1000;
 /**
  * Monotonic worker-progress measure for the stall watchdog.
  *
@@ -25,32 +81,86 @@ export function normalizeStallSnapshot(text) {
  * evidence of work. A rendered transcript is only known to have grown when it occupies more
  * non-empty rows than any prior sample. Same-row rewrites are deliberately ambiguous and do not
  * advance the clock: a recoverable early consult is safer than silencing the watchdog forever.
+ *
+ * CEILING: `transcriptRows` is a monotone high-water over the daemon's bounded pane read
+ * (PANE_READ_ROWS lines), so it is a one-way ratchet whose signal goes blind once the pane's
+ * content exceeds the read window — the same full window slides and `observe()` can never
+ * report row growth again. Past that point a `false` return means "unmeasurable", not "no
+ * output" — consumers making a kill decision (the dead-channel fast-kill) must check
+ * `rowSignalSaturated` and stand down on it.
  */
 export class StallProgressTracker {
-    transcriptRows = 0;
+    transcriptRows = 0; // non-empty high-water over the bounded read — the growth signal
+    rawWindowLines = 0; // raw-line high-water — the SATURATION signal (see the getter)
     seedSubmitted = false;
     contextTokens;
-    observe(sample) {
-        let advanced = false;
+    lastTokenGrowthAt; // undefined until the first token sample anchors the flat-clock
+    rowGrowthAt; // raw row-growth clock — NEVER suppressed by the flat-token rule
+    /** True once a sample FILLED the bounded read window on RAW lines (blanks and chrome-only
+     * rows included): the pane's real extent is then unknown — genuinely new content scrolls out
+     * of the read and the row high-water can never advance again — so a flat tracker is blindness,
+     * not silence. The raw window is the saturation signal, NOT the normalized non-empty count: a
+     * production `read(slot, PANE_READ_ROWS)` returns at most PANE_READ_ROWS lines including blank
+     * and chrome-only rows (measured 730 non-empty of 1000 on the codex-mcp-spinner fixture), so
+     * comparing the non-empty high-water against PANE_READ_ROWS could never engage and the
+     * fast-kill's stand-down was unreachable. Sticky by construction (the high-water never
+     * decreases). */
+    get rowSignalSaturated() {
+        return this.rawWindowLines >= PANE_READ_ROWS;
+    }
+    /** Raw row-growth clock: the last observe() that advanced the row high-water, recorded even
+     * when the flat-token rule suppresses the progress REPORT (observe returns false). T1 review:
+     * the dead-channel fast-kill's "no output growth" leg must read this, not the suppressed
+     * progress clock — a metered adapter whose sticky token counter freezes the report while the
+     * pane keeps streaming rows is alive, and only this clock sees it. */
+    get lastRowGrowthAt() {
+        return this.rowGrowthAt;
+    }
+    observe(sample, now = Date.now()) {
+        let rowsAdvanced = false;
+        // raw window high-water first — this is the saturation signal (rowSignalSaturated), and it
+        // must see the sample exactly as the bounded read returned it, blanks and chrome included.
+        const rawLines = sample.paneText.split("\n").length;
+        if (rawLines > this.rawWindowLines)
+            this.rawWindowLines = rawLines;
         const rows = normalizeStallSnapshot(sample.paneText)
             .split("\n")
             .filter((line) => line.trim().length > 0)
             .length;
         if (rows > this.transcriptRows) {
             this.transcriptRows = rows;
-            advanced = true;
+            rowsAdvanced = true;
+            this.rowGrowthAt = now; // raw signal — advances even when the report below is suppressed
         }
+        let seedAdvanced = false;
         if (sample.seedSubmitted && !this.seedSubmitted) {
             this.seedSubmitted = true;
-            advanced = true;
+            seedAdvanced = true;
         }
+        let tokensAdvanced = false;
         const tokens = sample.contextTokens;
         if (tokens !== undefined && Number.isFinite(tokens)) {
             if (tokens > (this.contextTokens ?? 0))
-                advanced = true;
-            this.contextTokens = Math.max(this.contextTokens ?? 0, tokens);
+                tokensAdvanced = true;
+            // T1 review: ANY movement re-anchors the flat-clock, not just a new high-water mark — a
+            // context compaction drops the counter, and the climb back below the old peak is still paid
+            // work. A high-water comparison would freeze the anchor forever on the first decrease. (The
+            // first token sample always counts as movement: contextTokens starts undefined.)
+            if (tokens !== this.contextTokens)
+                this.lastTokenGrowthAt = now;
+            this.contextTokens = tokens;
+        }
+        if (tokensAdvanced || seedAdvanced)
+            return true;
+        if (rowsAdvanced) {
+            // T1: row growth past the flat-token cap is cosmetic — the paid-work counter has not moved,
+            // so the inactivity window must NOT re-arm on it. A tracker that never sees a token sample
+            // (unmetered adapter) keeps the old row-growth behavior.
+            if (this.lastTokenGrowthAt !== undefined && now - this.lastTokenGrowthAt >= rowRearmTokenFlatMs)
+                return false;
+            return true;
         }
-        return advanced;
+        return false;
     }
 }
 // ─── v1.65 T2: LLM-bound transcript filter ──────────────────────────────────────────────────────

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

@@ -209,6 +209,18 @@ export type RegeneratedGoldenFrame = GoldenFrameCase & {
     readonly emitted: string;
 };
 export declare function regenerateGoldenFrames(binaryVersion?: string): Promise<readonly RegeneratedGoldenFrame[]>;
+/**
+ * Canonicalize the one release-owned token in an ACTIVE golden frame.
+ *
+ * The grammar is deliberately positional: plain output owns the whole first
+ * line, while a setup frame owns the right-anchored `v<semver> · binary ✓`
+ * suffix. The latter preserves the suffix's right edge, so a longer version
+ * does not turn renderer padding into drift while any actual alignment change
+ * still does. Retired rendered frames never enter this exception.
+ */
+export declare function normalizeGoldenFrameVersionForComparison(frame: GoldenFrameCase, bytes: string): string;
+/** An absent committed frame is a mismatch; it is never an empty agreement. */
+export declare function goldenFrameMatchesCommitted(frame: RegeneratedGoldenFrame, committed: string | undefined): boolean;
 export declare function findGoldenFrameMismatches(regenerated: readonly RegeneratedGoldenFrame[], committed: ReadonlyMap<string, string>): string[];
 export type RegeneratedColourFrame = ColourFrameCase & {
     readonly output: string;

package/dist/tui/cockpit/capture.js

@@ -564,13 +564,49 @@ export async function regenerateGoldenFrames(binaryVersion) {
     }
     return regenerated;
 }
+const SEMVER_TOKEN = String.raw `\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?`;
+const PLAIN_VERSION_HEADER = new RegExp(`^(tickmarkr v)(${SEMVER_TOKEN})$`, "u");
+const FRAME_VERSION_HEADER = new RegExp(`^(.*\\S)( +)v(${SEMVER_TOKEN})( · binary ✓)$`, "u");
+const COMPARISON_VERSION = "<binary-version>";
+/**
+ * Canonicalize the one release-owned token in an ACTIVE golden frame.
+ *
+ * The grammar is deliberately positional: plain output owns the whole first
+ * line, while a setup frame owns the right-anchored `v<semver> · binary ✓`
+ * suffix. The latter preserves the suffix's right edge, so a longer version
+ * does not turn renderer padding into drift while any actual alignment change
+ * still does. Retired rendered frames never enter this exception.
+ */
+export function normalizeGoldenFrameVersionForComparison(frame, bytes) {
+    if (isRetiredGoldenFrame(frame))
+        return bytes;
+    const lineBreak = bytes.indexOf("\n");
+    const header = lineBreak === -1 ? bytes : bytes.slice(0, lineBreak);
+    const rest = lineBreak === -1 ? "" : bytes.slice(lineBreak);
+    let normalized = header;
+    if (!frame.interactive || frame.ci) {
+        normalized = header.replace(PLAIN_VERSION_HEADER, `$1${COMPARISON_VERSION}`);
+    }
+    else {
+        normalized = header.replace(FRAME_VERSION_HEADER, (_match, prefix, gap, versionToken, suffix) => `${prefix}${" ".repeat(gap.length + versionToken.length)}v${COMPARISON_VERSION}${suffix}`);
+    }
+    return normalized === header ? bytes : `${normalized}${rest}`;
+}
+/** An absent committed frame is a mismatch; it is never an empty agreement. */
+export function goldenFrameMatchesCommitted(frame, committed) {
+    return committed !== undefined
+        && normalizeGoldenFrameVersionForComparison(frame, committed)
+            === normalizeGoldenFrameVersionForComparison(frame, frame.output);
+}
 export function findGoldenFrameMismatches(regenerated, committed) {
     // Membership is judged against the whole shipped manifest, retired cases
     // included: a retired fixture is claimed, so only its bytes are exempt.
     // Anything committed that no case claims is still named.
     const expected = new Set(GOLDEN_FRAME_CASES.map((frame) => frame.fixture));
     return [
-        ...regenerated.flatMap((frame) => committed.get(frame.fixture) === frame.output ? [] : [frame.fixture]),
+        ...regenerated.flatMap((frame) => goldenFrameMatchesCommitted(frame, committed.get(frame.fixture))
+            ? []
+            : [frame.fixture]),
         ...[...committed.keys()].filter((fixture) => !expected.has(fixture)),
     ].sort();
 }

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

@@ -39,6 +39,8 @@ export declare const KEYBAR_KEYS: {
 export type JournalRow = {
     readonly id: string;
     readonly time: string;
+    /** The complete recorded instant behind `time`; absent only on non-event/legacy rows. */
+    readonly timestamp?: string;
     readonly state: ComponentState;
     readonly text: string;
 };

package/dist/tui/cockpit/components.js

@@ -170,24 +170,24 @@ function statePresentation(state) {
         case "active":
             return {
                 glyph: GLYPHS.toggleActive,
-                color: `ansi256(${COCKPIT_DATA_RAMP[1].xterm})`,
+                color: COCKPIT_DATA_RAMP[1].hex,
             };
         case "inactive":
             return { glyph: GLYPHS.toggleInactive, dimmed: true };
         case "pass":
             return {
                 glyph: GLYPHS.pass,
-                color: `ansi256(${COCKPIT_DATA_RAMP[1].xterm})`,
+                color: COCKPIT_DATA_RAMP[1].hex,
             };
         case "fail":
             return {
                 glyph: GLYPHS.fail,
-                color: `ansi256(${COCKPIT_INKS.failure.xterm})`,
+                color: COCKPIT_INKS.failure.hex,
             };
         case "warn":
             return {
                 glyph: GLYPHS.attention,
-                color: `ansi256(${COCKPIT_INKS.warning.xterm})`,
+                color: COCKPIT_INKS.warning.hex,
             };
         case "neutral":
             return { glyph: GLYPHS.neutral, dimmed: true };
@@ -201,7 +201,7 @@ export function Panel({ title, focused = false, width, flexGrow, children, }) {
     const content = Children.map(children, (child) => typeof child === "string" || typeof child === "number"
         ? _jsx(BodyText, { children: child })
         : child);
-    return (_jsxs(Box, { flexDirection: "column", flexGrow: flexGrow, width: width, paddingX: 1, borderStyle: focused ? "double" : "round", borderColor: `ansi256(${focused ? COCKPIT_DATA_RAMP[0].xterm : COCKPIT_DATA_RAMP[3].xterm})`, borderDimColor: !focused, children: [_jsx(Box, { children: focused ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: `ansi256(${COCKPIT_DATA_RAMP[0].xterm})`, children: GLYPHS.pointer }), _jsxs(BodyText, { emphasis: "strong", children: [" ", title] })] })) : (_jsx(BodyText, { emphasis: "strong", children: title })) }), _jsx(Box, { flexDirection: "column", children: content })] }));
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: flexGrow, width: width, paddingX: 1, borderStyle: focused ? "double" : "round", borderColor: focused ? COCKPIT_DATA_RAMP[0].hex : COCKPIT_DATA_RAMP[3].hex, borderDimColor: !focused, children: [_jsx(Box, { children: focused ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: COCKPIT_DATA_RAMP[0].hex, children: GLYPHS.pointer }), _jsxs(BodyText, { emphasis: "strong", children: [" ", title] })] })) : (_jsx(BodyText, { emphasis: "strong", children: title })) }), _jsx(Box, { flexDirection: "column", children: content })] }));
 }
 export function CockpitGrid({ children, columns, columnContents, allocation, }) {
     const items = Children.toArray(children);
@@ -229,7 +229,7 @@ export function Sparkline({ samples, }) {
             const level = sparklineLevel(sample, minimum, maximum);
             const rampIndex = COCKPIT_DATA_RAMP.length - 1 - Math.round((level / (SPARKLINE_GLYPHS.length - 1)) * (COCKPIT_DATA_RAMP.length - 1));
             const ink = COCKPIT_DATA_RAMP[rampIndex] ?? COCKPIT_DATA_RAMP[0];
-            return (_jsx(Text, { color: `ansi256(${ink.xterm})`, children: SPARKLINE_GLYPHS[level] }, `${index}:${sample}`));
+            return (_jsx(Text, { color: ink.hex, children: SPARKLINE_GLYPHS[level] }, `${index}:${sample}`));
         }) }));
 }
 export function StatTile({ label, value, samples, focused, width, }) {
@@ -242,7 +242,7 @@ export function ProgressMeter({ value, width = 24, }) {
     const valueLabel = Number.isInteger(percentage)
         ? percentage.toFixed(0)
         : percentage.toFixed(1);
-    return (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", "aria-role": "progressbar", "aria-label": `${valueLabel}% complete`, children: [_jsx(Text, { color: `ansi256(${COCKPIT_DATA_RAMP[0].xterm})`, children: "█".repeat(filled) }), _jsx(Text, { dimColor: true, children: "░".repeat(safeWidth - filled) }), _jsxs(BodyText, { emphasis: "strong", children: [" ", valueLabel, "%"] })] }));
+    return (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", "aria-role": "progressbar", "aria-label": `${valueLabel}% complete`, children: [_jsx(Text, { color: COCKPIT_DATA_RAMP[0].hex, children: "█".repeat(filled) }), _jsx(Text, { dimColor: true, children: "░".repeat(safeWidth - filled) }), _jsxs(BodyText, { emphasis: "strong", children: [" ", valueLabel, "%"] })] }));
 }
 function OneLineItems({ children, width, label, }) {
     return (_jsx(Box, { flexDirection: "row", flexWrap: "nowrap", width: width, height: 1, overflow: "hidden", "aria-label": label, children: children }));
@@ -285,6 +285,6 @@ export function StatusStrip({ items, width, }) {
 }
 export function JournalRowPanel({ rows, width, focused, title = "JOURNAL", selection, hover, }) {
     return (_jsx(Panel, { title: title, focused: focused, width: width, children: rows.map((row, index) => (_jsxs(Box, { flexDirection: "row", flexWrap: "nowrap", height: 1, overflow: "hidden", children: [_jsx(BodyText, { emphasis: "dim", children: row.time }), _jsx(BodyText, { children: " " }), _jsx(StateGlyph, { state: row.state }), _jsx(BodyText, { emphasis: index === hover ? "strong" : "normal", children: index === hover ? HOVER_MARKER : " " }), index === selection && (_jsxs(BodyText, { emphasis: "strong", children: [GLYPHS.pointer, " "] })), index === hover
-                    ? (_jsx(Text, { inverse: true, color: `ansi256(${COCKPIT_DATA_RAMP[0].xterm})`, children: row.text }))
+                    ? (_jsx(Text, { inverse: true, color: COCKPIT_DATA_RAMP[0].hex, children: row.text }))
                     : _jsx(BodyText, { children: row.text })] }, row.id))) }));
 }

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

@@ -3,7 +3,14 @@ import type { RunViewId } from "./views.js";
 export declare const SPARKLINE_BUCKET_WINDOW = 12;
 export declare function selectSparklineBucketWidthMs(elapsedMs: number): number;
 type MetricSample = number | null;
-export type RunStatus = "done" | "failed" | "interrupted" | "running";
+/**
+ * What the run is, in one word. `parked` is first-class beside the rest because
+ * a run holding an unresolved `human` task owes the operator a verb — it is not
+ * done, and calling it done is the render OBS-252 caught. The task-level word
+ * for the same fact stays `human` (TaskState): that is the event the journal
+ * writes, and `parked` is what the fold of it means for the run.
+ */
+export type RunStatus = "done" | "failed" | "interrupted" | "parked" | "running";
 export type RunCockpitData = {
     readonly binaryVersion: string;
     readonly runId: string;
@@ -80,12 +87,30 @@ export type TaskRow = {
     readonly attempts?: number;
     readonly actor?: string;
     readonly lastEventTime?: string;
+    /** Complete UTC instant paired with `lastEventTime`; additive for existing consumers. */
+    readonly lastEventTimestamp?: string;
     readonly title?: string;
+    /**
+     * The park the task is standing in right now, as the daemon recorded it
+     * (`task-human` data.kind). A resolved park has no kind at all: the badge
+     * retires with the state it belonged to, so a merged task never wears the
+     * `gate-fail` it was released from an hour earlier (OBS-256).
+     */
+    readonly parkKind?: string;
+    /**
+     * Recorded merged, and only then. A task the journal carried to `done` has
+     * finished its work; a task the journal recorded a `merge` for has landed.
+     * The two are different rows, so a consumer drawing a check-mark has the fact
+     * that earns one rather than having to read `done` as if it were the same.
+     */
+    readonly merged?: true;
 };
 /** One recorded gate result. `details` is the record's own text, verbatim. */
 export type GateRow = {
     readonly id: string;
     readonly time: string;
+    /** Complete UTC instant paired with `time`; additive for existing consumers. */
+    readonly timestamp?: string;
     readonly state: ComponentState;
     readonly gate?: string;
     readonly taskId?: string;
@@ -99,8 +124,10 @@ export type FleetRow = {
     readonly model: string;
     readonly dispatches?: number;
     readonly lastEventTime?: string;
+    /** Complete UTC instant paired with `lastEventTime`; additive for existing consumers. */
+    readonly lastEventTimestamp?: string;
 };
-export type TaskState = "done" | "failed" | "human" | "pending" | "running" | "interrupted";
+export type TaskState = "completed" | "done" | "failed" | "human" | "pending" | "running" | "interrupted";
 /**
  * The source identities the named view's rows carry, in draw order. Selection
  * is repaired against these, so it follows a row across a refresh instead of