tickmarkr 1.64.0 → 1.66.0

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.64.0",
+  "version": "1.66.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",