tickmarkr 1.65.0 → 1.66.0

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

@@ -0,0 +1,5 @@
+import { type StudioOptions } from "../../tui/app.js";
+export declare function ui(_argv: string[], io?: Partial<StudioOptions>): Promise<string | {
+    out: string;
+    code: number;
+}>;

package/dist/cli/commands/ui.js

@@ -0,0 +1,13 @@
+import { StudioApp } from "../../tui/app.js";
+const NON_TTY_MSG = "tickmarkr ui: studio requires a TTY — use `tickmarkr fleet --print` or `tickmarkr status --watch` for line-mode output";
+export async function ui(_argv, io = {}) {
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    if (input.isTTY !== true || output.isTTY !== true) {
+        return { out: NON_TTY_MSG, code: 1 };
+    }
+    const app = new StudioApp({ input, output });
+    app.start();
+    await app.exited;
+    return "ui: closed";
+}

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -13,11 +13,12 @@ import { resume } from "./commands/resume.js";
 import { run } from "./commands/run.js";
 import { scope } from "./commands/scope.js";
 import { status } from "./commands/status.js";
+import { ui } from "./commands/ui.js";
 import { unlock } from "./commands/unlock.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, ui, unlock, approve, version,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -35,6 +36,7 @@ usage: tickmarkr <command>
   resume <id>   continue a run from its journal
   report <id>   cost/quality report (--md for committable execution record)
   profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)
+  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)
   unlock        remove a stale/garbage run lock (refuses if the holder is alive)
   approve <id> <task>  approve a parked human gate (--by <name> --reason <text>); takes effect on resume`;
 // pure, testable dispatcher: resolves a command, forwards argv, shapes the result — no side effects.

package/dist/tui/app.d.ts

@@ -0,0 +1,40 @@
+import { type OutputStream } from "../tui/engine.js";
+import type { InputStream } from "../tui/input.js";
+export type View = {
+    id: string;
+    label: string;
+    render(props: {
+        cols: number;
+        rows: number;
+    }): string[];
+};
+export type StudioOptions = {
+    input: InputStream;
+    output: OutputStream;
+};
+export declare class StudioApp {
+    private engine;
+    private views;
+    private active;
+    private showingHelp;
+    private notice;
+    private _lines;
+    private resolveExit;
+    readonly exited: Promise<void>;
+    constructor(opts: StudioOptions);
+    /** Current line model last rendered or prepared. */
+    get lines(): string[];
+    /** Labels of every registered view, in order. */
+    get viewLabels(): string[];
+    /** Enter the alternate screen and start routing input. */
+    start(): void;
+    /** Restore the terminal and release the input stream. */
+    stop(): void;
+    private bindKeys;
+    private setView;
+    private showNotice;
+    private paint;
+    private buildFrame;
+    private renderTabBar;
+    private renderHelp;
+}

package/dist/tui/app.js

@@ -0,0 +1,130 @@
+import { TerminalEngine } from "../tui/engine.js";
+import { createFleetView } from "./views/fleet-view.js";
+import { createPreviewView } from "./views/preview-view.js";
+import { createProfileView } from "./views/profile-view.js";
+import { createRoutingView } from "./views/routing-view.js";
+const MUTATION_KEYS = ["r", "s", "m", "return"];
+const READONLY_NOTICE = "read-only in v1.66 — write path ships in v1.67";
+export class StudioApp {
+    engine;
+    views;
+    active = 0;
+    showingHelp = false;
+    notice = null;
+    _lines = [];
+    resolveExit = null;
+    exited;
+    constructor(opts) {
+        this.engine = new TerminalEngine({
+            input: opts.input,
+            output: opts.output,
+            onResize: () => this.paint(),
+        });
+        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView()];
+        this.exited = new Promise((resolve) => {
+            this.resolveExit = resolve;
+        });
+    }
+    /** Current line model last rendered or prepared. */
+    get lines() {
+        return this._lines;
+    }
+    /** Labels of every registered view, in order. */
+    get viewLabels() {
+        return this.views.map((v) => v.label);
+    }
+    /** Enter the alternate screen and start routing input. */
+    start() {
+        this.bindKeys();
+        this.paint();
+        this.engine.start(this._lines);
+    }
+    /** Restore the terminal and release the input stream. */
+    stop() {
+        this.engine.stop();
+        if (this.resolveExit) {
+            this.resolveExit();
+            this.resolveExit = null;
+        }
+    }
+    bindKeys() {
+        // view switching
+        // Tab is decoded as the raw "\t" sequence by the micro-engine.
+        this.engine.key("\t", () => this.setView((this.active + 1) % this.views.length));
+        for (let i = 1; i <= this.views.length; i++) {
+            const idx = i - 1;
+            this.engine.key(String(i), () => this.setView(idx));
+        }
+        // help overlay
+        this.engine.key("?", () => {
+            this.showingHelp = true;
+            this.paint();
+        });
+        // dismissal / quit
+        this.engine.key("escape", () => {
+            if (this.showingHelp) {
+                this.showingHelp = false;
+                this.paint();
+            }
+            else {
+                this.stop();
+            }
+        });
+        this.engine.key("q", () => this.stop());
+        // mutation keys — read-only until the v1.67 write path
+        for (const key of MUTATION_KEYS) {
+            this.engine.key(key, () => this.showNotice());
+        }
+    }
+    setView(idx) {
+        this.active = idx;
+        this.showingHelp = false;
+        this.notice = null;
+        this.paint();
+    }
+    showNotice() {
+        this.notice = READONLY_NOTICE;
+        this.paint();
+    }
+    paint() {
+        this._lines = this.buildFrame();
+        this.engine.render(this._lines);
+    }
+    buildFrame() {
+        const { cols, rows } = this.engine.size;
+        const lines = [];
+        lines.push(this.renderTabBar());
+        if (this.showingHelp) {
+            lines.push(...this.renderHelp());
+        }
+        else {
+            const view = this.views[this.active];
+            lines.push(...view.render({ cols, rows: Math.max(rows - 2, 1) }));
+        }
+        if (this.notice) {
+            lines.push(this.notice);
+        }
+        return lines;
+    }
+    renderTabBar() {
+        const parts = ["tickmarkr ui ──"];
+        for (let i = 0; i < this.views.length; i++) {
+            const view = this.views[i];
+            const marker = i === this.active ? `*${view.label}` : view.label;
+            parts.push(`[${i + 1}]${marker}`);
+        }
+        return parts.join(" ");
+    }
+    renderHelp() {
+        return [
+            "Key bindings",
+            "1-4      switch view",
+            "tab      cycle views",
+            "?        show this help",
+            "esc / q  quit",
+            "r        re-probe (read-only)",
+            "s        save (read-only)",
+            "m        mode (read-only)",
+        ];
+    }
+}

package/dist/tui/engine.d.ts

@@ -0,0 +1,52 @@
+import { type Key, type KeyHandler, type InputStream } from "./input.js";
+export type { Key, KeyHandler };
+/** Writable stream with the small surface the engine needs. */
+export interface OutputStream {
+    isTTY?: boolean;
+    columns?: number;
+    rows?: number;
+    write: (chunk: string) => unknown;
+    on?(event: "resize", listener: () => void): this;
+    off?(event: "resize", listener: () => void): this;
+}
+export interface EngineOptions {
+    input: InputStream;
+    output: OutputStream;
+    onResize?: (cols: number, rows: number) => void;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Dependency-free terminal engine: alternate-screen line-diff renderer, named-key routing,
+ * resize tracking, and terminal restoration on every exit path including thrown handlers.
+ */
+export declare class TerminalEngine {
+    private opts;
+    private frame;
+    private input;
+    private lastLines;
+    private _cols;
+    private _rows;
+    private running;
+    private userHandlers;
+    constructor(opts: EngineOptions);
+    /** Enter the alternate screen, begin listening for keys and resize events. */
+    start(lines: string[]): void;
+    /** Restore the terminal and stop listening. Safe to call multiple times. */
+    stop(): void;
+    /** Update the line model; only changed lines are repainted. */
+    render(lines: string[]): void;
+    /** Register a handler for a named key. */
+    key(name: string, handler: KeyHandler): void;
+    /** Unregister a handler. */
+    unkey(name: string, handler: KeyHandler): void;
+    /** Trigger a full repaint at the new size. */
+    resize(cols: number, rows: number): void;
+    /** Current terminal size as last seen or reported by a resize event. */
+    get size(): {
+        cols: number;
+        rows: number;
+    };
+    private onResize;
+    private attachResize;
+    private detachResize;
+}

package/dist/tui/engine.js

@@ -0,0 +1,92 @@
+import { Frame } from "./frame.js";
+import { InputRouter } from "./input.js";
+/**
+ * Dependency-free terminal engine: alternate-screen line-diff renderer, named-key routing,
+ * resize tracking, and terminal restoration on every exit path including thrown handlers.
+ */
+export class TerminalEngine {
+    opts;
+    frame;
+    input;
+    lastLines = [];
+    _cols;
+    _rows;
+    running = false;
+    userHandlers = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        this.frame = new Frame(opts.output);
+        this.input = new InputRouter(opts.input);
+        this._cols = opts.output.columns ?? 80;
+        this._rows = opts.output.rows ?? 24;
+    }
+    /** Enter the alternate screen, begin listening for keys and resize events. */
+    start(lines) {
+        if (this.running)
+            return;
+        this.running = true;
+        this.lastLines = lines.slice();
+        this.frame.enter(this.lastLines);
+        this.input.start();
+        this.attachResize();
+    }
+    /** Restore the terminal and stop listening. Safe to call multiple times. */
+    stop() {
+        if (!this.running)
+            return;
+        this.detachResize();
+        this.input.stop();
+        this.frame.exit();
+        this.running = false;
+    }
+    /** Update the line model; only changed lines are repainted. */
+    render(lines) {
+        this.lastLines = lines.slice();
+        this.frame.render(this.lastLines);
+    }
+    /** Register a handler for a named key. */
+    key(name, handler) {
+        const wrapped = async (k) => {
+            try {
+                await handler(k);
+            }
+            catch (e) {
+                this.stop();
+                this.opts.onError?.(e);
+            }
+        };
+        this.userHandlers.set(handler, wrapped);
+        this.input.on(name, wrapped);
+    }
+    /** Unregister a handler. */
+    unkey(name, handler) {
+        const wrapped = this.userHandlers.get(handler);
+        if (wrapped) {
+            this.input.off(name, wrapped);
+            this.userHandlers.delete(handler);
+        }
+    }
+    /** Trigger a full repaint at the new size. */
+    resize(cols, rows) {
+        this._cols = cols;
+        this._rows = rows;
+        this.frame.resize(this.lastLines);
+        this.opts.onResize?.(cols, rows);
+    }
+    /** Current terminal size as last seen or reported by a resize event. */
+    get size() {
+        return { cols: this._cols, rows: this._rows };
+    }
+    onResize = () => {
+        this._cols = this.opts.output.columns ?? this._cols;
+        this._rows = this.opts.output.rows ?? this._rows;
+        this.frame.resize(this.lastLines);
+        this.opts.onResize?.(this._cols, this._rows);
+    };
+    attachResize() {
+        this.opts.output.on?.("resize", this.onResize);
+    }
+    detachResize() {
+        this.opts.output.off?.("resize", this.onResize);
+    }
+}

package/dist/tui/frame.d.ts

@@ -0,0 +1,22 @@
+/** A write target — anything with a write(chunk: string) method. */
+export interface OutputSink {
+    write: (chunk: string) => unknown;
+}
+/** Frame state + diff rendering. */
+export declare class Frame {
+    private out;
+    private prev;
+    private active;
+    constructor(out: OutputSink);
+    /** Enter the alternate screen, hide the cursor, and paint the initial frame. */
+    enter(lines: string[]): void;
+    /**
+     * Paint only the lines that differ from the previous model. Lines are addressed with
+     * absolute cursor positioning; unchanged rows produce no output.
+     */
+    render(lines: string[]): void;
+    /** Invalidate the cached frame so the next render writes every line. */
+    resize(lines: string[]): void;
+    /** Restore the terminal: show cursor and return to the normal screen buffer. */
+    exit(): void;
+}

package/dist/tui/frame.js

@@ -0,0 +1,56 @@
+// Line-diff renderer for the alternate screen. Maintains the previous line model and
+// repaints only rows that changed since the last render, keeping terminal traffic small.
+/** Frame state + diff rendering. */
+export class Frame {
+    out;
+    prev = [];
+    active = false;
+    constructor(out) {
+        this.out = out;
+    }
+    /** Enter the alternate screen, hide the cursor, and paint the initial frame. */
+    enter(lines) {
+        this.active = true;
+        this.prev = [];
+        this.out.write("\x1b[?1049h"); // alternate screen buffer
+        this.out.write("\x1b[?25l"); // hide cursor
+        this.render(lines);
+    }
+    /**
+     * Paint only the lines that differ from the previous model. Lines are addressed with
+     * absolute cursor positioning; unchanged rows produce no output.
+     */
+    render(lines) {
+        if (!this.active)
+            return;
+        const curr = lines.slice();
+        const max = Math.max(this.prev.length, curr.length);
+        for (let i = 0; i < max; i++) {
+            if (this.prev[i] !== curr[i]) {
+                this.out.write(`\x1b[${i + 1};1H`); // row i+1, column 1
+                this.out.write(curr[i] ?? "");
+                this.out.write("\x1b[K"); // clear to end of line
+            }
+        }
+        if (curr.length < this.prev.length) {
+            // The frame shrank — clear everything below the new last line.
+            this.out.write(`\x1b[${curr.length + 1};1H`);
+            this.out.write("\x1b[J");
+        }
+        this.prev = curr;
+    }
+    /** Invalidate the cached frame so the next render writes every line. */
+    resize(lines) {
+        this.prev = [];
+        this.render(lines);
+    }
+    /** Restore the terminal: show cursor and return to the normal screen buffer. */
+    exit() {
+        if (!this.active)
+            return;
+        this.out.write("\x1b[?25h"); // show cursor
+        this.out.write("\x1b[?1049l"); // normal screen buffer
+        this.active = false;
+        this.prev = [];
+    }
+}

package/dist/tui/input.d.ts

@@ -0,0 +1,41 @@
+/** Decoded keypress shape. */
+export interface Key {
+    name?: string;
+    sequence?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+}
+/** Handler for a named key. May be async. */
+export type KeyHandler = (key: Key) => void | Promise<void>;
+/** Readable stream with the small TTY surface the engine needs. */
+export interface InputStream extends NodeJS.ReadableStream {
+    isTTY?: boolean;
+    setRawMode?: (mode: boolean) => unknown;
+}
+/**
+ * Decode the next key at the start of a byte buffer. Returns the decoded key and
+ * how many bytes were consumed. Undefined when more bytes are needed.
+ */
+export declare function decodeOneKey(buf: Buffer): {
+    key: Key;
+    consumed: number;
+} | undefined;
+/** Routes decoded keypress events to handlers registered by key name. */
+export declare class InputRouter {
+    private input;
+    private handlers;
+    private started;
+    private buffer;
+    constructor(input: InputStream);
+    /** Register a handler for a named key (e.g. "up", "escape", "q"). */
+    on(name: string, handler: KeyHandler): void;
+    /** Remove a previously registered handler. */
+    off(name: string, handler: KeyHandler): void;
+    /** Start decoding keypresses from the input stream. Idempotent. */
+    start(): void;
+    /** Stop decoding and release the stream. Idempotent. */
+    stop(): void;
+    private onData;
+    private dispatch;
+}

package/dist/tui/input.js

@@ -0,0 +1,100 @@
+/**
+ * Decode the next key at the start of a byte buffer. Returns the decoded key and
+ * how many bytes were consumed. Undefined when more bytes are needed.
+ */
+export function decodeOneKey(buf) {
+    if (buf.length === 0)
+        return undefined;
+    const b0 = buf[0];
+    if (b0 === 0x1b) {
+        // CSI arrow sequences: ESC [ A/B/C/D. Keep an incomplete CSI buffered so
+        // arbitrary stream chunking cannot turn an arrow into Escape + plain keys.
+        if (buf[1] === 0x5b) {
+            if (buf.length < 3)
+                return undefined;
+            const name = buf[2] === 0x41 ? "up"
+                : buf[2] === 0x42 ? "down"
+                    : buf[2] === 0x43 ? "right"
+                        : buf[2] === 0x44 ? "left"
+                            : undefined;
+            if (name) {
+                return { key: { name, sequence: buf.subarray(0, 3).toString("binary") }, consumed: 3 };
+            }
+        }
+        // A lone ESC (or ESC followed by something we do not recognise) is Escape.
+        return { key: { name: "escape", sequence: "\x1b" }, consumed: 1 };
+    }
+    if (b0 === 0x0d || b0 === 0x0a) {
+        return { key: { name: "return", sequence: String.fromCharCode(b0) }, consumed: 1 };
+    }
+    if (b0 === 0x03) {
+        return { key: { name: "c", ctrl: true, sequence: "\x03" }, consumed: 1 };
+    }
+    if (b0 >= 0x20 && b0 < 0x7f) {
+        return { key: { name: String.fromCharCode(b0), sequence: String.fromCharCode(b0) }, consumed: 1 };
+    }
+    // Unknown byte: consume it without a name so it does not block the stream.
+    return { key: { sequence: String.fromCharCode(b0) }, consumed: 1 };
+}
+/** Routes decoded keypress events to handlers registered by key name. */
+export class InputRouter {
+    input;
+    handlers = new Map();
+    started = false;
+    buffer = Buffer.alloc(0);
+    constructor(input) {
+        this.input = input;
+    }
+    /** Register a handler for a named key (e.g. "up", "escape", "q"). */
+    on(name, handler) {
+        let set = this.handlers.get(name);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(name, set);
+        }
+        set.add(handler);
+    }
+    /** Remove a previously registered handler. */
+    off(name, handler) {
+        this.handlers.get(name)?.delete(handler);
+    }
+    /** Start decoding keypresses from the input stream. Idempotent. */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.input.setRawMode?.(true);
+        this.input.on("data", this.onData);
+        this.input.resume();
+    }
+    /** Stop decoding and release the stream. Idempotent. */
+    stop() {
+        if (!this.started)
+            return;
+        this.input.off("data", this.onData);
+        this.input.setRawMode?.(false);
+        this.input.pause();
+        this.started = false;
+    }
+    onData = (chunk) => {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "binary");
+        this.buffer = Buffer.concat([this.buffer, data]);
+        while (this.buffer.length > 0) {
+            const result = decodeOneKey(this.buffer);
+            if (!result)
+                break;
+            this.dispatch(result.key);
+            this.buffer = this.buffer.subarray(result.consumed);
+        }
+    };
+    dispatch(key) {
+        const name = key.name ?? key.sequence;
+        if (!name)
+            return;
+        const set = this.handlers.get(name);
+        if (!set)
+            return;
+        for (const handler of set)
+            void handler(key);
+    }
+}

package/dist/tui/views/fleet-view.d.ts

@@ -0,0 +1,69 @@
+import type { View } from "../app.js";
+import type { AuthHealth } from "../../adapters/types.js";
+import type { Tier } from "../../config/config.js";
+import type { TelemetryRow } from "../../run/journal.js";
+/** One discovered adapter and its classified models (cfg.tiers via channels()). */
+export type FleetRosterEntry = {
+    adapter: string;
+    models: {
+        model: string;
+        tier: Tier;
+        channel: "sub" | "api";
+    }[];
+};
+/** Provenance notes harvested from overlay `# comment`s (fleet-overlay.ts shapes). */
+export type FleetProvenanceNotes = {
+    denyAdapters?: Record<string, string>;
+    denyModels?: Record<string, string>;
+};
+/** Everything the roster renders — loaded by the caller, never by the render path. */
+export type FleetViewData = {
+    adapters: FleetRosterEntry[];
+    /** Doctor cache contents (doctor.json), keyed by adapter id. */
+    health: Record<string, AuthHealth>;
+    /** Age of the doctor cache in ms; null when no probe data exists. */
+    doctorAgeMs: number | null;
+    denyAdapters: string[];
+    /** routing.deny.models entries in channelKey form ("adapter:model"). */
+    denyModels: string[];
+    notes?: FleetProvenanceNotes;
+    /** Telemetry folded from recent run journals (readAllTelemetry); runId optional. */
+    telemetry: (TelemetryRow & {
+        runId?: string;
+    })[];
+};
+/** Per-channel health digest, folded from journal telemetry rows only. */
+export type ChannelHealth = {
+    key: string;
+    tasks: number;
+    attempts: number;
+    done: number;
+    failed: number;
+    human: number;
+    overruns: number;
+    quotaFailovers: number;
+    /** Sum of OBSERVED gateFails; null when no row carried the field (unobserved, never 0). */
+    gateFails: number | null;
+    medianDurationMs: number | null;
+    lastOutcome: TelemetryRow["outcome"] | null;
+};
+/** Fold journal telemetry rows into a per-channel health digest keyed by channelKey
+ *  ("adapter:model"). The digest derives from journal telemetry (TelemetryRow, the rows the
+ *  daemon appends to each run's telemetry.jsonl) rather than any new state file: this module
+ *  reads nothing and writes nothing — the caller folds rows out of the existing run journals
+ *  (readAllTelemetry) and the fold is a pure function of them, same telemetry in, same digest
+ *  out. */
+export declare function foldChannelHealth(rows: (TelemetryRow & {
+    runId?: string;
+})[]): Map<string, ChannelHealth>;
+/** The studio View plus the roster's own key seam. The T2 shell binds only view-level keys, so
+ *  expand/collapse and selection are driven through key() — the same names the engine decodes. */
+export type FleetView = View & {
+    /** Handle a decoded key name ("up" | "down" | "left" | "right" | "space" | "return"). */
+    key(name: string): void;
+    /** Whether an adapter's model rows are currently shown. */
+    expanded(adapter: string): boolean;
+    /** channelKey of the cursor's channel, or null when the cursor sits on an adapter row. */
+    selectedChannel(): string | null;
+};
+export declare function createFleetView(data?: FleetViewData): FleetView;

package/dist/tui/views/fleet-view.js

@@ -0,0 +1,243 @@
+import { GLYPHS, bold, dim, fail, legend } from "../../brand.js";
+const keyOf = (r) => `${r.adapter}:${r.model}`;
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+/** Fold one row list into a single digest. Journals are append-only, so input order is
+ *  chronological and the last row's outcome is the channel's last observed outcome. */
+function foldRows(key, rows) {
+    const d = {
+        key, tasks: 0, attempts: 0, done: 0, failed: 0, human: 0,
+        overruns: 0, quotaFailovers: 0, gateFails: null, medianDurationMs: null, lastOutcome: null,
+    };
+    for (const r of rows) {
+        d.tasks += 1;
+        d.attempts += r.attempts;
+        if (r.outcome === "done")
+            d.done += 1;
+        else if (r.outcome === "failed")
+            d.failed += 1;
+        else
+            d.human += 1;
+        if (r.overrun === true)
+            d.overruns += 1;
+        if (r.quotaFailover === true)
+            d.quotaFailovers += 1;
+        // absent = unobserved: an all-legacy channel keeps gateFails null rather than a fake 0
+        if (r.gateFails !== undefined)
+            d.gateFails = (d.gateFails ?? 0) + r.gateFails;
+        d.lastOutcome = r.outcome;
+    }
+    if (rows.length)
+        d.medianDurationMs = median(rows.map((r) => r.durationMs));
+    return d;
+}
+/** Fold journal telemetry rows into a per-channel health digest keyed by channelKey
+ *  ("adapter:model"). The digest derives from journal telemetry (TelemetryRow, the rows the
+ *  daemon appends to each run's telemetry.jsonl) rather than any new state file: this module
+ *  reads nothing and writes nothing — the caller folds rows out of the existing run journals
+ *  (readAllTelemetry) and the fold is a pure function of them, same telemetry in, same digest
+ *  out. */
+export function foldChannelHealth(rows) {
+    const byChannel = new Map();
+    for (const r of rows) {
+        const key = keyOf(r);
+        const list = byChannel.get(key);
+        if (list)
+            list.push(r);
+        else
+            byChannel.set(key, [r]);
+    }
+    const out = new Map();
+    for (const [key, list] of byChannel)
+        out.set(key, foldRows(key, list));
+    return out;
+}
+// fleet.ts formatAge voice — the operator already reads "12m old" on the classic fleet screen.
+const formatCacheAge = (ageMs) => {
+    if (ageMs === null)
+        return "no probe data";
+    const mins = Math.floor(ageMs / 60_000);
+    if (mins < 60)
+        return `${mins}m old`;
+    return `${Math.floor(mins / 60)}h old`;
+};
+const fmtDuration = (ms) => {
+    const s = Math.round(ms / 1000);
+    return s < 60 ? `${s}s` : `${(s / 60).toFixed(1)}m`;
+};
+const trunc = (s, n) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
+const note = (n) => (n ? ` — ${n}` : "");
+const plural = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+/** doctor.ts model-status voice: authed / unauthed with reason+date / unknown. A non-installed
+ *  adapter is "unknown" whatever stale modelAuth its doctor entry still carries — the roster row
+ *  and the detail panel must never disagree about whether a channel is usable. */
+function modelAuthText(health, model) {
+    const v = health?.installed ? health.modelAuth?.[model] : undefined;
+    if (!v)
+        return "unknown";
+    if (v.authed)
+        return "authed";
+    return `unauthed: ${trunc(v.reason ?? "probe failed", 40)} (${v.probedAt.slice(0, 10)})`;
+}
+/** A channel is denied by its own routing.deny.models entry OR by its adapter's deny — the roster
+ *  row and the detail panel resolve deny through this one seam so an adapter-level deny can never
+ *  read as available on the model row while the panel below it says "denied". Adapter deny wins
+ *  and carries the adapter's note: it is the broader reason. */
+function denyOf(data, adapter, model) {
+    if (data.denyAdapters.includes(adapter))
+        return { denied: true, note: data.notes?.denyAdapters?.[adapter] };
+    const key = `${adapter}:${model}`;
+    if (data.denyModels.includes(key))
+        return { denied: true, note: data.notes?.denyModels?.[key] };
+    return { denied: false };
+}
+function digestLine(d, noun) {
+    if (d.tasks === 0)
+        return `  journals: no recent telemetry for this ${noun}`;
+    const parts = [
+        `${d.tasks} task${d.tasks === 1 ? "" : "s"}`,
+        `${d.attempts} attempt${d.attempts === 1 ? "" : "s"}`,
+        `${d.done} done`,
+    ];
+    if (d.failed)
+        parts.push(`${d.failed} failed`);
+    if (d.human)
+        parts.push(`${d.human} human`);
+    if (d.medianDurationMs !== null)
+        parts.push(`median ${fmtDuration(d.medianDurationMs)}`);
+    if (d.gateFails !== null)
+        parts.push(`${d.gateFails} gate-fails`);
+    parts.push(`${d.overruns} overrun${d.overruns === 1 ? "" : "s"}`);
+    parts.push(`${d.quotaFailovers} quota failover${d.quotaFailovers === 1 ? "" : "s"}`);
+    return `  journals: ${parts.join(" · ")}`;
+}
+export function createFleetView(data) {
+    // One expanded bit per adapter, default expanded — the roster shows everything at a glance.
+    const expandedMap = new Map((data?.adapters ?? []).map((a) => [a.adapter, true]));
+    let cursor = 0;
+    const visibleRows = () => {
+        const rows = [];
+        for (const a of data?.adapters ?? []) {
+            rows.push({ kind: "adapter", adapter: a.adapter });
+            if (expandedMap.get(a.adapter) !== false) {
+                for (const m of a.models)
+                    rows.push({ kind: "model", adapter: a.adapter, model: m.model });
+            }
+        }
+        return rows;
+    };
+    const view = {
+        id: "fleet",
+        label: "Fleet",
+        key(name) {
+            const rows = visibleRows();
+            if (!rows.length)
+                return;
+            if (name === "up")
+                cursor = Math.max(cursor - 1, 0);
+            else if (name === "down")
+                cursor = Math.min(cursor + 1, rows.length - 1);
+            else if (name === "left" || name === "right" || name === "space" || name === "return") {
+                const row = rows[cursor];
+                if (!row)
+                    return;
+                const cur = expandedMap.get(row.adapter) !== false;
+                const next = name === "left" ? false : name === "right" ? true : !cur;
+                expandedMap.set(row.adapter, next);
+                if (row.kind === "model" && !next) {
+                    // collapsing from a model row parks the cursor on the adapter header row
+                    cursor = visibleRows().findIndex((r) => r.kind === "adapter" && r.adapter === row.adapter);
+                }
+            }
+            const n = visibleRows().length;
+            cursor = Math.min(Math.max(cursor, 0), n - 1);
+        },
+        expanded(adapter) {
+            return expandedMap.get(adapter) !== false;
+        },
+        selectedChannel() {
+            const row = visibleRows()[cursor];
+            return row?.kind === "model" ? `${row.adapter}:${row.model}` : null;
+        },
+        render(_props) {
+            if (!data) {
+                // T2 stub surface — the shell registers the view before any data source is wired.
+                return ["Fleet view", "Harness roster and health (read-only in v1.66)."];
+            }
+            const digest = foldChannelHealth(data.telemetry);
+            const lines = [bold("Fleet view — harness roster")];
+            lines.push(legend(`doctor cache: ${formatCacheAge(data.doctorAgeMs)} · ${data.adapters.length} adapters · ` +
+                `${data.telemetry.length} journal rows · ↑↓ select · → expand · ← collapse · space toggle`));
+            const rows = visibleRows();
+            rows.forEach((row, i) => {
+                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
+                const h = data.health[row.adapter];
+                if (row.kind === "adapter") {
+                    const marker = expandedMap.get(row.adapter) !== false ? "▾" : "▸";
+                    const state = !h?.installed
+                        ? `${fail(GLYPHS.fail)} not installed`
+                        : `${h.version ?? "installed"} · ${h.authed ? "authed" : "unauthed"}`;
+                    const counts = h?.installed ? ` · ${plural(entryOf(data, row.adapter)?.models.length ?? 0, "model")}` : "";
+                    const deny = data.denyAdapters.includes(row.adapter)
+                        ? ` · ${fail("denied")}${note(data.notes?.denyAdapters?.[row.adapter])}`
+                        : "";
+                    lines.push(`${pointer}${marker} ${bold(row.adapter)}  ${state}${counts}${deny}`);
+                    return;
+                }
+                const m = data.adapters.find((a) => a.adapter === row.adapter)?.models.find((mm) => mm.model === row.model);
+                if (!m)
+                    return;
+                const key = `${row.adapter}:${row.model}`;
+                const auth = modelAuthText(h, row.model);
+                const dn = denyOf(data, row.adapter, row.model);
+                const deny = dn.denied ? `  ${fail(GLYPHS.fail)} denied${note(dn.note)}` : "";
+                const d = digest.get(key);
+                const healthBit = d && d.tasks > 0 ? `  ${dim(`${d.done}/${d.tasks} done`)}` : "";
+                lines.push(`${pointer}  ${row.model.padEnd(28)} [${m.tier}] ${m.channel}  ${auth}${deny}${healthBit}`);
+            });
+            lines.push(...detailPanel(data, digest, rows[cursor]));
+            return lines;
+        },
+    };
+    return view;
+}
+const entryOf = (data, adapter) => data.adapters.find((a) => a.adapter === adapter);
+/** The bottom panel: the selected channel's journal-derived health digest (or the adapter fold
+ *  when the cursor sits on an adapter header row). */
+function detailPanel(data, digest, row) {
+    if (!row)
+        return [];
+    const h = data.health[row.adapter];
+    if (row.kind === "model") {
+        const key = `${row.adapter}:${row.model}`;
+        const m = data.adapters.find((a) => a.adapter === row.adapter)?.models.find((mm) => mm.model === row.model);
+        const v = h?.installed ? h.modelAuth?.[row.model] : undefined;
+        // an unauthed reading already carries its probe date inside modelAuthText — appending it again
+        // printed the same day twice ("… (2026-07-21) (probed 2026-07-21)")
+        const probed = v?.authed ? ` (probed ${v.probedAt.slice(0, 10)})` : "";
+        const dn = denyOf(data, row.adapter, row.model);
+        const d = digest.get(key);
+        const lines = [
+            "",
+            dim(`── ${key} ──`),
+            `  tier ${m?.tier ?? "???"} · ${m?.channel ?? "?"} · ${modelAuthText(h, row.model)}${probed} · ${dn.denied ? "denied" : "enabled"}${note(dn.note)}`,
+            digestLine(d ?? foldRows(key, []), "channel"),
+        ];
+        if (d?.lastOutcome)
+            lines.push(`  last outcome: ${d.lastOutcome}`);
+        return lines;
+    }
+    const folded = foldRows(row.adapter, data.telemetry.filter((r) => r.adapter === row.adapter));
+    const state = !h?.installed ? "not installed" : `${h.version ?? "installed"} · ${h.authed ? "authed" : "unauthed"}`;
+    const denied = data.denyAdapters.includes(row.adapter);
+    const enabled = `${denied ? "denied" : "enabled"}${denied ? note(data.notes?.denyAdapters?.[row.adapter]) : ""}`;
+    return [
+        "",
+        dim(`── ${row.adapter} (adapter) ──`),
+        `  ${state} · ${plural(entryOf(data, row.adapter)?.models.length ?? 0, "model")} · ${enabled}`,
+        digestLine(folded, "adapter"),
+    ];
+}

package/dist/tui/views/preview-view.d.ts

@@ -0,0 +1,7 @@
+import type { WorkerAdapter } from "../../adapters/types.js";
+import type { View } from "../app.js";
+export type PreviewViewDeps = {
+    cwd?: string;
+    adapters?: WorkerAdapter[];
+};
+export declare function createPreviewView(deps?: PreviewViewDeps): View;

package/dist/tui/views/preview-view.js

@@ -0,0 +1,80 @@
+import { allAdapters, discoverChannels, readDoctor } from "../../adapters/registry.js";
+import { costSignal } from "../../cli/commands/fleet-picker.js";
+import { loadGraph } from "../../graph/graph.js";
+import { SHAPES } from "../../graph/schema.js";
+import { route, RoutingError } from "../../route/router.js";
+import { resolveRunMode } from "../../run/daemon.js";
+import { loadRoutingProfile } from "../../run/journal.js";
+// Same exploration setting as the candidate picker (rankCandidates routes noExplore so repeated
+// calls agree): a due probe must never make a preview row disagree with the picker's rank-1 for
+// the same graph and channel set. Mirrors fleet.ts's PREVIEW_EXPLORE.
+const PREVIEW_EXPLORE = { noExplore: true };
+// The no-graph stand-in: one synthetic task per shape so the consequence surface still shows what
+// the router WOULD do with this fleet. Same shape as fleet.ts's previewTask.
+function syntheticTask(shape) {
+    return {
+        id: `preview-${shape}`,
+        title: `${shape} preview`,
+        goal: "preview",
+        shape,
+        complexity: 3,
+        acceptance: ["done"],
+        deps: [],
+        files: [],
+        context: [],
+        gates: ["build", "test", "lint", "evidence", "scope", "acceptance", "review"],
+        humanGate: false,
+        status: "pending",
+        evidence: { commits: [], artifacts: [], gateResults: [] },
+    };
+}
+// The consequence surface: the routing table a plan dry-run would produce, one row per task with
+// the chosen channel, the route()'s why-provenance verbatim, and the picker's cost signal. Every
+// render re-reads graph/config/doctor cache from disk (refresh on demand = repaint); the render
+// path is strictly read-only — doctor cache only, never probeAll, so a preview spends no tokens
+// and invokes no agent. Unroutable rows render the RoutingError in place, like plan's `!!` rows.
+function renderPreview(deps) {
+    const cwd = deps.cwd ?? process.cwd();
+    const adapters = deps.adapters ?? allAdapters();
+    let graph = null;
+    try {
+        graph = loadGraph(cwd);
+    }
+    catch {
+        graph = null; // absent or invalid — fall through to the synthetic per-shape set
+    }
+    const { cfg, mode, source } = resolveRunMode(cwd, { spec: graph?.mode });
+    const cached = readDoctor(cwd);
+    const channels = discoverChannels(cfg, adapters, cached ?? {});
+    const profile = loadRoutingProfile(cwd, cfg, { preview: true });
+    const tasks = graph ? graph.tasks : SHAPES.map(syntheticTask);
+    const lines = [
+        "Preview view — plan dry run (read-only: no writes, no probes, no token spend)",
+        graph
+            ? `source: compiled graph (${tasks.length} task${tasks.length === 1 ? "" : "s"}) · mode: ${mode.mode} (${source}) · explore off (picker parity) · ${channels.length} channels`
+            : `source: no compiled graph — synthetic per-shape task set (${tasks.length} shapes) · mode: ${mode.mode} (${source}) · explore off (picker parity) · ${channels.length} channels`,
+    ];
+    if (!cached)
+        lines.push("doctor cache missing — rows route against zero channels; run `tickmarkr doctor` (the preview never probes)");
+    lines.push("");
+    for (const t of tasks) {
+        try {
+            const r = route(t, cfg, channels, profile, undefined, undefined, PREVIEW_EXPLORE);
+            const a = r.assignment;
+            lines.push(`  ${t.id.padEnd(16)} ${t.shape.padEnd(10)} → ${a.adapter}:${a.model} [${a.channel}/${a.tier}]  ${costSignal(a, cfg.pricing)}  — ${r.provenance}`);
+        }
+        catch (e) {
+            if (!(e instanceof RoutingError))
+                throw e;
+            lines.push(`  ${t.id.padEnd(16)} ${t.shape.padEnd(10)} !! ${e.message}`);
+        }
+    }
+    return lines;
+}
+export function createPreviewView(deps = {}) {
+    return {
+        id: "preview",
+        label: "Preview",
+        render: () => renderPreview(deps),
+    };
+}

package/dist/tui/views/profile-view.d.ts

@@ -0,0 +1,15 @@
+import { type TickmarkrConfig } from "../../config/config.js";
+import { type RoutingProfile } from "../../route/profile.js";
+import type { View } from "../app.js";
+export type ProfileViewData = {
+    cfg: TickmarkrConfig;
+    /** the loaded routing profile; undefined ⇒ cold (no telemetry in the window) */
+    profile?: RoutingProfile;
+};
+export type ProfileViewDeps = {
+    /** injected fixture data — with data present the render path never touches the filesystem */
+    data?: ProfileViewData;
+    /** where the no-arg studio shell loads config and the profile from (default: process.cwd()) */
+    repoRoot?: string;
+};
+export declare function createProfileView(deps?: ProfileViewDeps): View;

package/dist/tui/views/profile-view.js

@@ -0,0 +1,93 @@
+import { channelKey } from "../../adapters/types.js";
+import { loadConfig } from "../../config/config.js";
+import { AVAIL_WEIGHT, cellsOf, cellSummary, EXPLORE_CAP, HALF_LIFE_RUNS, learnedScore, MIN_SAMPLES, } from "../../route/profile.js";
+import { loadRoutingProfile } from "../../run/journal.js";
+const fmtSigned = (n) => (n >= 0 ? `+${n.toFixed(3)}` : n.toFixed(3));
+// No-arg shell path (app.ts constructs views without deps): the SAME loader the daemon's router
+// calls (daemon.ts:194), with the profile command's inspection-surface preview flag so the tab
+// still renders under routing.learned:off — labeled inert in the header, as `tickmarkr profile`
+// does. Best-effort: a load failure degrades to an explanatory note instead of breaking the studio.
+function loadDefaultData(repoRoot) {
+    try {
+        const cfg = loadConfig(repoRoot);
+        return { cfg, profile: loadRoutingProfile(repoRoot, cfg, { preview: true }) };
+    }
+    catch {
+        return null;
+    }
+}
+// A configured pin that beat a higher-scored learned channel, or null. route() consults the map
+// pin before any learned sorting, so when another channel's learned score for the shape tops the
+// pin's, the pin is overriding learned evidence — the case this inspector exists to name.
+function pinOverride(profile, cfg, shape, pin, scoreOpts) {
+    const pinChKey = channelKey({ adapter: pin.via, model: pin.model });
+    const pinChannel = cfg.tiers[pin.via]?.channel ?? "sub";
+    const pinScore = learnedScore(profile, shape, pinChKey, pinChannel, scoreOpts);
+    let top = null;
+    for (const { shape: s, chKey, channel } of cellsOf(profile)) {
+        if (s !== shape || (chKey === pinChKey && channel === pinChannel))
+            continue;
+        const score = learnedScore(profile, shape, chKey, channel, scoreOpts);
+        if (score > pinScore && (!top || score > top.score))
+            top = { chKey, channel, score };
+    }
+    if (!top)
+        return null;
+    return `${shape}: pin ${pinChKey} (score ${fmtSigned(pinScore)}) overrides higher-scored ${top.chKey} (${top.channel}, score ${fmtSigned(top.score)})`;
+}
+export function createProfileView(deps = {}) {
+    const data = deps.data ?? loadDefaultData(deps.repoRoot ?? process.cwd());
+    return {
+        id: "profile",
+        label: "Profile",
+        render: () => {
+            const lines = ["Profile view — learned-routing inspector (read-only)"];
+            if (!data) {
+                lines.push("profile data unavailable — see `tickmarkr profile` for the line-mode surface");
+                return lines;
+            }
+            const { cfg, profile } = data;
+            const halfLife = cfg.routing.learnedTuning?.halfLifeRuns ?? HALF_LIFE_RUNS;
+            const availWeight = cfg.routing.learnedTuning?.availWeight ?? AVAIL_WEIGHT;
+            // router.ts:29's exploreCap — the exploration fence in effect, not the bare module default
+            const cap = cfg.routing.explore?.cap ?? EXPLORE_CAP;
+            lines.push(`routing.learned: ${cfg.routing.learned}${cfg.routing.learned === "off" ? " (preview — routing is inert)" : ""}`);
+            lines.push(`half-life: ${halfLife} runs   availability weight: ${availWeight}   exploration cap: ${cap}`);
+            if (!profile || profile.cells.size === 0) {
+                // ROUTE-07's cold start, explained: an empty profile scores every channel exactly NEUTRAL,
+                // so routing is byte-identical static routing until real samples accumulate.
+                lines.push("cold start — no learned evidence yet:", `  every channel scores exactly neutral and routing follows the static policy`, `  until a shape×channel cell accumulates ${MIN_SAMPLES} samples.`);
+                return lines;
+            }
+            const scoreOpts = { availWeight: cfg.routing.learnedTuning?.availWeight };
+            lines.push(`  ${"shape".padEnd(10)} ${"channel".padEnd(28)} ${"class".padEnd(5)} ${"score".padEnd(8)} samples           decay     explore`);
+            for (const { shape, chKey, channel, cell } of cellsOf(profile)) {
+                const s = cellSummary(cell);
+                const score = learnedScore(profile, shape, chKey, channel, scoreOpts);
+                // decayed ⇔ rank-decay folded older runs below full weight (n_eff < n_raw); fresh ⇔ all
+                // evidence at weight 1. The two states must never render alike.
+                const decay = s.nEff < s.nRaw ? "decayed" : "fresh";
+                const remaining = Math.max(0, cap - cell.dispatches);
+                const explore = remaining > 0 ? `left ${remaining}` : "spent";
+                const disc = s.discounted > 0 ? `  disc=${s.discounted}` : "";
+                const cold = s.cold ? `  cold (n<${MIN_SAMPLES})` : "";
+                lines.push(`  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(5)} ${fmtSigned(score).padEnd(8)} ${`n_eff=${s.nEff} n_raw=${s.nRaw}`.padEnd(18)} ${decay.padEnd(9)} ${explore}${disc}${cold}`);
+            }
+            const overrides = [];
+            for (const [shape, entry] of Object.entries(cfg.routing.map).sort(([a], [b]) => a.localeCompare(b))) {
+                if (!entry.pin)
+                    continue;
+                const named = pinOverride(profile, cfg, shape, entry.pin, scoreOpts);
+                if (named)
+                    overrides.push(named);
+            }
+            if (overrides.length) {
+                lines.push("pins overriding higher-scored learned channels:", ...overrides.map((l) => `  ${l}`));
+            }
+            else if (Object.values(cfg.routing.map).some((e) => e?.pin)) {
+                lines.push("pins: none overrides a higher-scored learned channel");
+            }
+            return lines;
+        },
+    };
+}

package/dist/tui/views/routing-view.d.ts

@@ -0,0 +1,29 @@
+import { type BillingChannel } from "../../adapters/types.js";
+import { type RoutingMode, type TickmarkrConfig } from "../../config/config.js";
+import { type Shape, type Task } from "../../graph/schema.js";
+import type { RoutingProfile } from "../../route/profile.js";
+import type { View } from "../app.js";
+export type RoutingViewData = {
+    cfg: TickmarkrConfig;
+    channels: BillingChannel[];
+    /** active routing mode for the header; absent ⇒ cfg.routing.mode ?? "risk-based" */
+    mode?: RoutingMode;
+    profile?: RoutingProfile;
+};
+export type RoutingViewDeps = {
+    /** injected fixture data — with data present the render path never touches the filesystem */
+    data?: RoutingViewData;
+    /** where the no-arg studio shell loads config from (default: process.cwd()) */
+    repoRoot?: string;
+};
+export type RoutingView = View & {
+    /** open the read-only candidate inspector for a shape (default: the selected grid row) */
+    openInspector(shape?: Shape): void;
+    closeInspector(): void;
+    moveCursor(delta: number): void;
+    readonly selectedShape: Shape;
+    /** the inspector's candidate rows — exactly the picker's candidateRow strings, in rank order */
+    inspectorRows(): string[] | null;
+};
+export declare function routingPreviewTask(shape: Shape): Task;
+export declare function createRoutingView(deps?: RoutingViewDeps): RoutingView;

package/dist/tui/views/routing-view.js

@@ -0,0 +1,98 @@
+import { channelsFromConfig } from "../../adapters/types.js";
+import { candidateRow, shapeCandidates } from "../../cli/commands/fleet-picker.js";
+import { INTEGRITY_FLOOR_SHAPES, loadConfigWithMode, } from "../../config/config.js";
+import { SHAPES } from "../../graph/schema.js";
+// Same preview task fleet.ts's picker ranks (one per shape, complexity 3): the inspector must
+// rank the exact inputs the fleet editor ranks, or the two surfaces could disagree.
+export function routingPreviewTask(shape) {
+    return {
+        id: "routing-preview",
+        title: "routing preview",
+        goal: "preview",
+        shape,
+        complexity: 3,
+        acceptance: ["done"],
+        deps: [],
+        files: [],
+        context: [],
+        gates: ["build", "test", "lint", "evidence", "scope", "acceptance", "review"],
+        humanGate: false,
+        status: "pending",
+        evidence: { commits: [], artifacts: [], gateResults: [] },
+    };
+}
+const isIntegrity = (shape) => INTEGRITY_FLOOR_SHAPES.includes(shape);
+// No-arg shell path (app.ts constructs views without deps): load the operator's resolved config
+// and derive channels from the configured tier table. Best-effort — a load failure degrades the
+// view to an explanatory note instead of breaking the studio.
+function loadDefaultData(repoRoot) {
+    try {
+        const { cfg, mode } = loadConfigWithMode(repoRoot);
+        const channels = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg));
+        return { cfg, channels, mode: mode.mode };
+    }
+    catch {
+        return null;
+    }
+}
+export function createRoutingView(deps = {}) {
+    const data = deps.data ?? loadDefaultData(deps.repoRoot ?? process.cwd());
+    let cursor = 0;
+    let inspector = null;
+    return {
+        id: "routing",
+        label: "Routing",
+        get selectedShape() {
+            return SHAPES[cursor];
+        },
+        moveCursor(delta) {
+            cursor = (cursor + delta + SHAPES.length) % SHAPES.length;
+        },
+        openInspector(shape) {
+            if (!data)
+                return;
+            const target = shape ?? SHAPES[cursor];
+            // THE parity seam: rank through the same shared picker glue the fleet editor uses — no
+            // comparator lives here — so rows, cost signals, and provenance match the router's choice.
+            const ranked = shapeCandidates(routingPreviewTask(target), data.cfg, data.channels, data.profile);
+            inspector = { shape: target, rows: ranked.map((c) => candidateRow(c, data.cfg.pricing)) };
+        },
+        closeInspector() {
+            inspector = null;
+        },
+        inspectorRows() {
+            return inspector ? [...inspector.rows] : null;
+        },
+        render: () => {
+            const lines = ["Routing view — per-shape policy grid (read-only)"];
+            if (!data) {
+                lines.push("routing data unavailable — see `tickmarkr fleet --print` for the line-mode surface");
+                return lines;
+            }
+            const { cfg } = data;
+            const mode = data.mode ?? cfg.routing.mode ?? "risk-based";
+            lines.push(`mode: ${mode}`);
+            lines.push(`  ${"shape".padEnd(10)}${"floor".padEnd(10)}${"pin".padEnd(20)}prefer`);
+            for (const [i, shape] of SHAPES.entries()) {
+                const entry = cfg.routing.map[shape];
+                const floor = cfg.routing.floors[shape] ?? "—";
+                const marker = isIntegrity(shape) ? "*" : "";
+                const pin = entry?.pin ? `${entry.pin.via}:${entry.pin.model}` : "—";
+                const prefer = entry?.prefer?.length ? entry.prefer.join(", ") : "—";
+                const sel = i === cursor ? "❯" : " ";
+                lines.push(`${sel} ${shape.padEnd(10)}${`${floor}${marker}`.padEnd(10)}${pin.padEnd(20)}${prefer}`);
+            }
+            lines.push("* integrity set: never below frontier");
+            lines.push(`pick: ${SHAPES[cursor]} — enter opens the candidate inspector (read-only)`);
+            if (inspector) {
+                lines.push(`─ candidates: ${inspector.shape} — the fleet picker ranking for the same inputs ──`);
+                if (inspector.rows.length === 0)
+                    lines.push("  (no routable candidates)");
+                for (const [j, row] of inspector.rows.entries()) {
+                    lines.push(`${j === 0 ? "❯ " : "  "}${row}`);
+                }
+            }
+            return lines;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.65.0",
+  "version": "1.66.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",