tickmarkr 1.85.0 → 1.87.0

package/dist/run/daemon.js

@@ -1,11 +1,11 @@
 import { createHash, randomBytes } from "node:crypto";
 import { shq } from "../adapters/types.js";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { stringify } from "yaml";
 import { classifyDeadChannel, NO_TRAILER_SUMMARY, trailerPattern, UNPARSEABLE_TRAILER_SUMMARY, writePrompt } from "../adapters/prompt.js";
-import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
+import { allAdapters, getAdapter, probeAll, readDoctor, rolePools } from "../adapters/registry.js";
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { DEFAULT_DIFF_CAP, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, } from "../config/config.js";
@@ -631,6 +631,71 @@ async function cherryPickCommits(wt, commits) {
     }
     return carried;
 }
+// T7 (v1.86): a first run-end append that fails AFTER partial bytes landed leaves a torn tail at
+// EOF with no newline; a blind retry would glue the run-end line onto those bytes and readJsonl's
+// torn-line tolerance would drop the retry too — no terminal record despite a successful write.
+// Terminating the torn fragment keeps it on disk (dropped as a malformed line, never truncated) so
+// the retried run-end lands on a line of its own.
+const terminateTornJournalTail = (journalPath) => {
+    if (!existsSync(journalPath))
+        return;
+    const size = statSync(journalPath).size;
+    if (size === 0)
+        return;
+    const fd = openSync(journalPath, "r");
+    try {
+        const tail = Buffer.alloc(1);
+        if (readSync(fd, tail, 0, 1, size - 1) === 1 && tail[0] !== 0x0a)
+            appendFileSync(journalPath, "\n");
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+// T7 (v1.86): the fatal handler must never eat the error it reports. Both journal calls are guarded,
+// so a sink failure is reported ALONGSIDE the original error (console.error — the dispatcher's
+// operator-visible line stays the one-line form), never instead of it: a read failure degrades the
+// duplicate-run-end check to "unknown" and fails toward recording; the append is retried ONCE; and
+// a persistently unwritable sink reports a crash naming the journal path and carrying NO terminal
+// record, rather than fabricating an ended run on evidence the harness could not write. (OBS-313:
+// with the sink dead the crash CAUSE is unrecordable — recorded as an observation, not papered over.)
+function recordFatalRunEnd(journal, runId, branch, err) {
+    const original = err instanceof Error ? err.message : String(err);
+    try {
+        if (journal.read().some((e) => e.event === "run-end"))
+            return; // already terminal — nothing to add
+    }
+    catch (readErr) {
+        console.error(`tickmarkr ${runId}: journal read failed while recording the fatal run-end (${readErr instanceof Error ? readErr.message : String(readErr)}) — original error: ${original}`);
+    }
+    const record = {
+        runId,
+        branch,
+        done: [],
+        failed: [],
+        human: [],
+        blocked: [],
+        pending: [],
+        phase: "setup",
+        fatal: true,
+        error: original,
+    };
+    try {
+        journal.append("run-end", undefined, record);
+        return;
+    }
+    catch {
+        // one retry below — the first failure is reported only if the retry also fails
+    }
+    const journalPath = join(journal.dir, "journal.jsonl");
+    try {
+        terminateTornJournalTail(journalPath);
+        journal.append("run-end", undefined, record);
+    }
+    catch (retryErr) {
+        console.error(`tickmarkr ${runId}: run crashed — no terminal record written; journal sink unwritable at ${journalPath} (${retryErr instanceof Error ? retryErr.message : String(retryErr)}) — original error: ${original}`);
+    }
+}
 export async function runDaemon(repoRoot, opts = {}) {
     // v1.51 T2 / OBS-89 (v1.60): retired --quality env seam. Mode resolution owns premium routing;
     // route() no longer reads the retired env at all, so the old entrypoint scrub is gone with it.
@@ -664,7 +729,12 @@ export async function runDaemon(repoRoot, opts = {}) {
         // v1.51 T4: every dispatch provenance line begins with the mode and its source; when a pin won
         // the route (the final "→ " segment is a pin, not a degraded-to-auto tail) it names the mode it bypassed.
         const dispatchProvenance = (p) => `mode ${rm.mode.mode} (${rm.source})${p.split("→ ").pop().startsWith("pin ") ? ` — pin bypasses mode ${rm.mode.mode}` : ""} · ${p}`;
-        const channels = discoverChannels(cfg, adapters, health);
+        // v1.87 T2: one pool per seat role, built once. `channels` stays the WORKER pool — every routing
+        // call below reads it exactly as before — while the judge, review and consult seats each receive
+        // the pool their own deny scope allows, so routing.deny.workers benches a channel for dispatch
+        // without also removing it from the seats that verify the work.
+        const pools = rolePools(cfg, adapters, health);
+        const channels = pools.worker;
         // v1.6 ROUTE-06: build the learned profile ONCE at startup (never per task, never in the comparator).
         // No preview — the daemon honors routing.learned:off and gets undefined; this snapshot is immutable
         // for the run, so this run's own telemetry never feeds back into its own routing.
@@ -1135,7 +1205,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // D-07: consult panes self-clean when the verdict is read (keepLlm) — only "forever" keeps them.
                 // v1.54 T1: channels = this run's doctor-filtered live list — consult.prefer seat liveness
                 // is judged against it, never rebuilt from config (installed-but-unauthed seats would stall).
-                { keep: keepLlm, onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined, runId, channels });
+                { keep: keepLlm, onSlot: keepLlm ? (s) => keptSlots.push(s) : undefined, runId, channels: pools.consult });
             };
             // returns true → continue attempting, false → task is terminal (parked)
             // trigger (why the consult ran) is threaded in so the decompose/human park keeps its cause —
@@ -1281,7 +1351,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     journal.phaseStart(t.id, "gates");
                     const { results } = await runGates(resumedTask, {
                         worktree: wt, baseRef: taskBase, result: priorResult, author: gateAuthor,
-                        commands, baseline, channels, adapters, cfg, artifactDir: journal.dir,
+                        commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
                         // a recheck re-verifies a human's release: it never selects tests down, it runs the suite.
                         pipeline: "v185",
                         via: cfg.visibility.llm === "pane"
@@ -2441,7 +2511,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     journal.phaseStart(t.id, "gates");
                     ({ results, commits } = await runGates(t, {
                         worktree: wt, baseRef: taskBase, result, author: assignment,
-                        commands, baseline, channels, adapters, cfg, artifactDir: journal.dir,
+                        commands, baseline, channels: pools.review, judgeChannels: pools.judge, adapters, cfg, artifactDir: journal.dir,
                         pipeline: "v185", selectTests: !testGateFailed,
                         via: cfg.visibility.llm === "pane"
                             ? {
@@ -2719,20 +2789,11 @@ export async function runDaemon(repoRoot, opts = {}) {
         return summary;
     }
     catch (err) {
-        if (runStarted && !taskLoopStarted && !journal.read().some((e) => e.event === "run-end")) {
-            journal.append("run-end", undefined, {
-                runId,
-                branch,
-                done: [],
-                failed: [],
-                human: [],
-                blocked: [],
-                pending: [],
-                phase: "setup",
-                fatal: true,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
+        // T7 (v1.86): guarded — a journal read/append failure while recording the fatal run-end is
+        // reported alongside err, never instead of it; recordFatalRunEnd never throws, so the original
+        // error (message, stack, cause) always reaches the caller verbatim.
+        if (runStarted && !taskLoopStarted)
+            recordFatalRunEnd(journal, runId, branch, err);
         throw err;
     }
     finally {

package/dist/run/journal.js

@@ -195,7 +195,7 @@ export function structuredFindings(gate, details, _scopeFiles = []) {
 const VOLATILE_TOKENS = [
     [/\u001b\[[0-9;]*[a-zA-Z]/g, ""], // ANSI styling
     [/\b\d{4}-\d{2}-\d{2}[T ][\d:]+(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g, "<ts>"], // timestamps
-    [/\brun-\d{8}-\d{6}\b/g, "<run>"], // run identifiers
+    [/\brun-\d{8}-\d{6}(?:-\d{16})?\b/g, "<run>"], // run identifiers
     [/\b0x[0-9a-fA-F]+\b/g, "<addr>"], // memory addresses
     // An absolute path INTO the repo keeps its repo-relative tail — that tail IS identity (a defect in
     // daemon.ts is not a defect in journal.ts); only the machine/worktree prefix ahead of it is volatile.
@@ -227,15 +227,67 @@ const eraseVolatile = (text) => VOLATILE_TOKENS.reduce((out, [re, replacement])
 // difference and banned a retry that was never redundant. Newlines survive (payload spans cannot
 // cross one) and the line-wise trim below finishes the job.
 const collapseRuns = (text) => text.replace(/[^\S\n]+/g, " ");
+// v1.85 T34: the runner's TALLY moves with the base, not with the defect. When another task merges
+// ahead and adds test files, vitest re-counts the suite — `192 passed (197)` becomes `193 passed
+// (198)` — while the FAIL headlines name the same defect in the same order, so a substantively
+// identical gate failure re-fingerprinted and gate-fingerprint-cap never counted the repeat
+// (measured on T21 in run-20260805-164546: details at 17:33:02 and 18:11:01 differ only so).
+//
+// Why provenance AND shape, and why not digits as a class: a blanket \d+ collapse also erases counts
+// that ARE identity — the failed-assertion count, the failing-suite count, an exit status, an error
+// code — and the rule above governs: a missed cap costs one extra round, a false cap bans a
+// legitimate retry. So the mask is gated on PROVENANCE first: only lines inside the `failing tests:`
+// block baseline.ts:209-219 emits (up to its blank-line/`new failure fingerprints` boundary) are
+// eligible, which keeps review prose, quoted diffs and assertion payloads structurally unreachable —
+// and that block's own `FAIL … > test name` headlines are excluded by SHAPE: only a line that starts
+// with the runner's own `Tests`/`Test Files` summary token is a tally line.
+//
+// Masked tally FIELDS, exactly: the passed count, the skipped and todo counts, and the derived
+// parenthesized total immediately following the tally sequence. Deliberately KEPT (a reader uses
+// each of them to tell two failures apart): every `N failed` count on the line (which suites and how
+// many assertions actually broke — the defect's identity), everything after the derived total (an
+// appended `| exit 1`, an appended `(404)` code), and every other number anywhere.
+const RUNNER_TALLY_LINE = /^([ \t]*(?:Test Files|Tests)[ \t]+)((?:\d+ (?:failed|passed|skipped|todo)[ \t]*\|[ \t]*)*\d+ (?:failed|passed|skipped|todo))([ \t]*\(\d+\))?(.*)$/;
+const TALLY_MOVED_FIELD = /\d+ (?=passed|skipped|todo)/g;
+const maskTallyLine = (line) => {
+    const m = RUNNER_TALLY_LINE.exec(line);
+    if (!m)
+        return line;
+    const fields = m[2].replace(TALLY_MOVED_FIELD, "#");
+    const total = (m[3] ?? "").replace(/\d+/, "#");
+    return m[1] + fields + total + m[4];
+};
+// Computed on the FULL details text BEFORE any payload split: every recorded tally-bearing detail
+// carries the `failing tests:` header, so gating on it closes the false-line-start axis (the mask
+// never sees a slice boundary) and the wrong-provenance axis in one place.
+const maskRunnerTallies = (text) => {
+    let inBlock = false;
+    return text
+        .split("\n")
+        .map((line) => {
+        if (!inBlock) {
+            if (line.trim() === "failing tests:")
+                inBlock = true;
+            return line;
+        }
+        if (line.trim() === "" || line.startsWith("new failure fingerprints")) {
+            inBlock = false;
+            return line;
+        }
+        return maskTallyLine(line);
+    })
+        .join("\n");
+};
 /** Normalized identity of a gate failure: the same defect, seen twice, normalizes to the same bytes. */
 export function normalizeGateFailure(details) {
+    const masked = maskRunnerTallies(details);
     let out = "";
     let last = 0;
-    for (const m of details.matchAll(PAYLOAD_SPAN)) {
-        out += collapseRuns(eraseVolatile(details.slice(last, m.index))) + m[0];
+    for (const m of masked.matchAll(PAYLOAD_SPAN)) {
+        out += collapseRuns(eraseVolatile(masked.slice(last, m.index))) + m[0];
         last = m.index + m[0].length;
     }
-    out += collapseRuns(eraseVolatile(details.slice(last)));
+    out += collapseRuns(eraseVolatile(masked.slice(last)));
     return out.split("\n").map((l) => l.trim()).filter(Boolean).join("\n");
 }
 // Two normalized-identical failures of one gate on one task buy no more rounds (the ladder cannot fix
@@ -538,9 +590,37 @@ export function engagementComparable(events, loadedHash) {
         return { comparable: false, reason: "unbound" };
     return recorded === loadedHash ? { comparable: true, recorded } : { comparable: false, reason: "mismatch", recorded };
 }
+const RUN_SEQUENCE_WIDTH = 16;
+// The daemon mints before acquiring graph.lock, and each CLI invocation has fresh module state. Claim
+// a repository-state ticket with mkdir's atomic EEXIST boundary instead: a losing process advances and
+// retries, while the winning directory remains as the durable high-water evidence for later invocations.
+function claimRunSequence(repoRoot = process.cwd()) {
+    const dir = join(tickmarkrDir(repoRoot), "run-id-sequence");
+    mkdirSync(dir, { recursive: true });
+    const allocated = readdirSync(dir).filter((name) => /^\d{16}$/.test(name));
+    let candidate = allocated.reduce((max, name) => {
+        const value = BigInt(name);
+        return value > max ? value : max;
+    }, 0n) + 1n;
+    while (true) {
+        const suffix = candidate.toString().padStart(RUN_SEQUENCE_WIDTH, "0");
+        if (suffix.length > RUN_SEQUENCE_WIDTH)
+            throw new Error("run id sequence exhausted");
+        try {
+            mkdirSync(join(dir, suffix));
+            return suffix;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            candidate += 1n;
+        }
+    }
+}
 export function newRunId(now = new Date()) {
     const p = (n, w = 2) => String(n).padStart(w, "0");
-    return `run-${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+    const instant = `${now.getUTCFullYear()}${p(now.getUTCMonth() + 1)}${p(now.getUTCDate())}-${p(now.getUTCHours())}${p(now.getUTCMinutes())}${p(now.getUTCSeconds())}`;
+    return `run-${instant}-${claimRunSequence()}`;
 }
 // Sol #4: one strict parser for every journal open/create path — generated run-… ids plus test
 // suffix chars only; forbid path separators, dot-segments, and empty ids.
@@ -578,7 +658,7 @@ function readJsonl(path) {
     return out;
 }
 // Cross-run telemetry for Phase-12 profile derivation: the last K runs' rows, each
-// tagged with its runId (runIds are zero-padded run-YYYYMMDD-HHMMSS ⇒ plain .sort() is
+// tagged with its runId (runIds are zero-padded run-UTCYYYYMMDD-HHMMSS-sequence ⇒ plain .sort() is
 // chronological, same as latestRunId). Rows are facts, not classifications — Phase 12
 // owns the quality-denominator/reward policy. A safeParse failure drops that one row
 // (same posture as a torn line); a garbage row must never crash profile derivation.
@@ -589,7 +669,7 @@ export function readAllTelemetry(repoRoot, lastK, opts = {}) {
     if (!existsSync(dir))
         return [];
     let runIds = readdirSync(dir).filter((d) => d.startsWith("run-")).sort();
-    // VIS-03 reset cursor: runIds are zero-padded run-YYYYMMDD-HHMMSS ⇒ string > is chronological
+    // VIS-03 reset cursor: UTC clock fields and a fixed-width sequence make string > chronological
     if (opts.after)
         runIds = runIds.filter((id) => id > opts.after);
     runIds = runIds.slice(-lastK);

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.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/theme.d.ts

@@ -7,19 +7,25 @@ export type ColourValue = {
 export declare const LOGO_RAMP: readonly [84, 78, 41, 35];
 /** Near-black panel fill against which every data shade must remain legible. */
 export declare const COCKPIT_SURFACE: "#1a1a19";
-/** Bright-to-deep, single-hue data ink. Depth communicates magnitude, never tile identity. */
+/**
+ * Bright-to-deep, single-hue data ink. Depth communicates magnitude, never tile identity.
+ * Anchored on xterm 114 (#87d787) — operator-chosen 2026-08-03 — with the hue (OKLab 144.2°)
+ * held constant down the ramp; steps descend in even OKLab lightness (0.094) and were searched
+ * and verified through guardDataRamp below. hex is the rendered ink (truecolor terminals);
+ * xterm is the nearest-distinct 256-colour fallback, documentation not render source.
+ */
 export declare const COCKPIT_DATA_RAMP: readonly [{
-    readonly xterm: 84;
-    readonly hex: "#5fff5f";
+    readonly xterm: 114;
+    readonly hex: "#87d787";
 }, {
-    readonly xterm: 41;
-    readonly hex: "#00d75f";
+    readonly xterm: 71;
+    readonly hex: "#5bbc5e";
 }, {
-    readonly xterm: 35;
-    readonly hex: "#00af5f";
+    readonly xterm: 65;
+    readonly hex: "#4f9a51";
 }, {
     readonly xterm: 29;
-    readonly hex: "#00875f";
+    readonly hex: "#437944";
 }];
 /** Documented near-misses retained as guard fixtures, not special cases in the guard. */
 export declare const EXCLUDED_DATA_SHADES: {
@@ -38,17 +44,17 @@ export declare const EXCLUDED_DATA_SHADES: {
  */
 export declare const COCKPIT_INKS: {
     readonly dataRamp: readonly [{
-        readonly xterm: 84;
-        readonly hex: "#5fff5f";
+        readonly xterm: 114;
+        readonly hex: "#87d787";
     }, {
-        readonly xterm: 41;
-        readonly hex: "#00d75f";
+        readonly xterm: 71;
+        readonly hex: "#5bbc5e";
     }, {
-        readonly xterm: 35;
-        readonly hex: "#00af5f";
+        readonly xterm: 65;
+        readonly hex: "#4f9a51";
     }, {
         readonly xterm: 29;
-        readonly hex: "#00875f";
+        readonly hex: "#437944";
     }];
     readonly warning: {
         readonly xterm: 214;
@@ -65,17 +71,17 @@ export declare const COCKPIT_INKS: {
 };
 /** Every drawable cockpit ink; the panel surface and text emphasis are not inks. */
 export declare const COCKPIT_INK_VOCABULARY: readonly [{
-    readonly xterm: 84;
-    readonly hex: "#5fff5f";
+    readonly xterm: 114;
+    readonly hex: "#87d787";
 }, {
-    readonly xterm: 41;
-    readonly hex: "#00d75f";
+    readonly xterm: 71;
+    readonly hex: "#5bbc5e";
 }, {
-    readonly xterm: 35;
-    readonly hex: "#00af5f";
+    readonly xterm: 65;
+    readonly hex: "#4f9a51";
 }, {
     readonly xterm: 29;
-    readonly hex: "#00875f";
+    readonly hex: "#437944";
 }, {
     readonly xterm: 214;
     readonly hex: "#ffaf00";
@@ -105,16 +111,16 @@ export declare const TEXT_EMPHASIS_TOKENS: {
 /** Deliberate 16-colour choices. Renderers select this map; they do not infer one. */
 export declare const REDUCED_COLOUR_MAPPING: {
     readonly dataRamp: readonly [{
-        readonly from: "#5fff5f";
+        readonly from: "#87d787";
         readonly to: "bright-green";
     }, {
-        readonly from: "#00d75f";
+        readonly from: "#5bbc5e";
         readonly to: "green";
     }, {
-        readonly from: "#00af5f";
+        readonly from: "#4f9a51";
         readonly to: "green";
     }, {
-        readonly from: "#00875f";
+        readonly from: "#437944";
         readonly to: "dim-green";
     }];
     readonly warning: {

package/dist/tui/cockpit/theme.js

@@ -3,12 +3,18 @@ import { BRAND_RAMP, GLYPHS } from "../../brand.js";
 export const LOGO_RAMP = BRAND_RAMP;
 /** Near-black panel fill against which every data shade must remain legible. */
 export const COCKPIT_SURFACE = "#1a1a19";
-/** Bright-to-deep, single-hue data ink. Depth communicates magnitude, never tile identity. */
+/**
+ * Bright-to-deep, single-hue data ink. Depth communicates magnitude, never tile identity.
+ * Anchored on xterm 114 (#87d787) — operator-chosen 2026-08-03 — with the hue (OKLab 144.2°)
+ * held constant down the ramp; steps descend in even OKLab lightness (0.094) and were searched
+ * and verified through guardDataRamp below. hex is the rendered ink (truecolor terminals);
+ * xterm is the nearest-distinct 256-colour fallback, documentation not render source.
+ */
 export const COCKPIT_DATA_RAMP = [
-    { xterm: 84, hex: "#5fff5f" },
-    { xterm: 41, hex: "#00d75f" },
-    { xterm: 35, hex: "#00af5f" },
-    { xterm: 29, hex: "#00875f" },
+    { xterm: 114, hex: "#87d787" },
+    { xterm: 71, hex: "#5bbc5e" },
+    { xterm: 65, hex: "#4f9a51" },
+    { xterm: 29, hex: "#437944" },
 ];
 /** Documented near-misses retained as guard fixtures, not special cases in the guard. */
 export const EXCLUDED_DATA_SHADES = {

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

@@ -1,5 +1,4 @@
 import type { ReactNode } from "react";
-import { type SaveTarget } from "../save.js";
 export type FleetListRow = {
     id: string;
     content: ReactNode;
@@ -22,17 +21,3 @@ export declare function FleetReviewScreen({ title, legend, diff, }: {
     legend: string;
     diff: string;
 }): import("react").JSX.Element;
-export type DiffConfirmationProps = {
-    target: SaveTarget;
-    targetPath: string;
-    diff: string;
-    liveRun: boolean;
-};
-export declare function DiffConfirmationScreen(props: DiffConfirmationProps): import("react").JSX.Element;
-export declare function StudioScreen({ tabs, active, lines, status, children, }: {
-    tabs: string[];
-    active: number;
-    lines: string[];
-    status?: string;
-    children?: ReactNode;
-}): import("react").JSX.Element;

package/dist/tui/ink/components.js

@@ -1,7 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { GLYPHS } from "../../brand.js";
-import { RELOAD_GUARD_NOTICE } from "../save.js";
 function keyedLines(lines) {
     const occurrences = new Map();
     return lines.map((text) => {
@@ -24,19 +23,3 @@ export function FleetListScreen({ title, legend, rows, cursor, details = [], })
 export function FleetReviewScreen({ title, legend, diff, }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));
 }
-export function DiffConfirmationScreen(props) {
-    return _jsx(TextLines, { lines: [
-            `Save overlay — ${props.targetPath} (${props.target === "repo" ? "repository" : "global"} target)`,
-            "t toggle target · y confirm · n/esc cancel",
-            ...(props.liveRun ? [RELOAD_GUARD_NOTICE] : []),
-            "─ diff ─",
-            props.diff || "(no overlay changes)",
-        ] });
-}
-export function StudioScreen({ tabs, active, lines, status = "no staged changes", children, }) {
-    const tabBar = [
-        "tickmarkr ui ──",
-        ...tabs.map((label, index) => `[${index + 1}]${index === active ? "*" : ""}${label}`),
-    ].join(" ");
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: tabBar }), children ?? _jsx(TextLines, { lines: lines }), _jsx(Text, { dimColor: true, children: status })] }));
-}

package/dist/tui/ink/fleet-app.d.ts

@@ -1,4 +1,4 @@
-import type { AuthHealth, WorkerAdapter } from "../../adapters/types.js";
+import { type AuthHealth, type WorkerAdapter } from "../../adapters/types.js";
 import type { MapEntry, RoutingMode, Tier } from "../../config/config.js";
 import { type Shape } from "../../graph/schema.js";
 export type FleetSteeringKey = "review" | "consult";
@@ -40,6 +40,7 @@ type AgentCli = {
 };
 export type FleetModelGroup = {
     adapter: string;
+    vendor?: string;
     rows: Array<{
         model: string;
         tier?: Tier;
@@ -51,6 +52,8 @@ export type FleetClassification = {
     model: string;
     tier: Tier;
     note: string;
+    vendor?: string;
+    channel?: "sub" | "api";
 };
 export type FleetModeOption = {
     id: RoutingMode;