tickmarkr 1.72.0 → 1.74.0

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

@@ -1,337 +0,0 @@
-import { GLYPHS, bold, dim, fail, legend, warn } 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;
-}
-/** Detect deny-vs-pin conflicts from the shared staging model. The buffer's CURRENT state holds
- *  both views' staged state — the fleet view's deny/allow + tier edits and the routing view's
- *  pin/floor edits — so reading it sees the combination before anything is saved. A conflict is
- *  a pinned channel denied by its own entry OR by its adapter's deny (the adapter deny reaches
- *  every channel under it, same rule as denyOf). */
-export function stagedConflicts(staging) {
-    const cur = staging.current;
-    const byChannel = new Map();
-    for (const [shape, entry] of Object.entries(cur.map)) {
-        const pin = entry?.pin;
-        if (!pin)
-            continue;
-        const key = `${pin.via}:${pin.model}`;
-        if (cur.denyModels.includes(key) || cur.denyAdapters.includes(pin.via)) {
-            byChannel.set(key, [...(byChannel.get(key) ?? []), shape]);
-        }
-    }
-    return [...byChannel.entries()].map(([channelKey, shapes]) => ({ channelKey, shapes }));
-}
-/** Rows whose staged state differs from the loaded (saved) state: adapter deny flips, channel
- *  deny flips, and tier overrides. Staged rows render marked so an unsaved edit never reads as
- *  saved state. Same JSON leaf-comparison semantics as the staging model's own delta count. */
-function stagedRowSets(staging) {
-    const cur = staging.current;
-    const saved = staging.loadedState;
-    const flipped = (a, b) => new Set([...a.filter((x) => !b.includes(x)), ...b.filter((x) => !a.includes(x))]);
-    const channels = flipped(cur.denyModels, saved.denyModels);
-    const tierAdapters = new Set([...Object.keys(cur.tiers), ...Object.keys(saved.tiers)]);
-    for (const adapter of tierAdapters) {
-        const models = new Set([
-            ...Object.keys(cur.tiers[adapter] ?? {}),
-            ...Object.keys(saved.tiers[adapter] ?? {}),
-        ]);
-        for (const model of models) {
-            if (JSON.stringify(cur.tiers[adapter]?.[model]) !== JSON.stringify(saved.tiers[adapter]?.[model])) {
-                channels.add(`${adapter}:${model}`);
-            }
-        }
-    }
-    return { adapters: flipped(cur.denyAdapters, saved.denyAdapters), channels };
-}
-/** The roster renders the buffer's CURRENT state when a staging model is attached: deny lists
- *  and tier badges come from the buffer, everything else (health, telemetry, notes, row shape)
- *  from the injected facts. Without staging the injected facts render as-is (saved state). */
-function overlayStaged(data, staging) {
-    if (!staging)
-        return data;
-    const cur = staging.current;
-    return {
-        ...data,
-        denyAdapters: cur.denyAdapters,
-        denyModels: cur.denyModels,
-        adapters: data.adapters.map((a) => ({
-            ...a,
-            models: a.models.map((m) => ({ ...m, tier: cur.tiers[a.adapter]?.[m.model]?.tier ?? m.tier })),
-        })),
-    };
-}
-/** Sorted in-place toggle so a stage-then-unstage leaves the list byte-identical to loaded. */
-const toggleIn = (list, value) => {
-    const i = list.indexOf(value);
-    if (i >= 0)
-        list.splice(i, 1);
-    else
-        list.push(value);
-    list.sort();
-};
-// 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, staging) {
-    // 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;
-        },
-        toggleDenyAdapter(adapter) {
-            staging?.apply((buffer) => toggleIn(buffer.denyAdapters, adapter));
-        },
-        toggleDenyChannel(channelKey) {
-            staging?.apply((buffer) => toggleIn(buffer.denyModels, channelKey));
-        },
-        stageTierOverride(channelKey, tier) {
-            const split = channelKey.indexOf(":");
-            if (split <= 0)
-                return;
-            const adapter = channelKey.slice(0, split);
-            const model = channelKey.slice(split + 1);
-            staging?.apply((buffer) => {
-                buffer.tiers[adapter] ??= {};
-                // spread keeps an existing provenance note riding the staged assignment
-                buffer.tiers[adapter][model] = { ...buffer.tiers[adapter][model], tier };
-            });
-        },
-        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 eff = overlayStaged(data, staging);
-            const staged = staging ? stagedRowSets(staging) : null;
-            const conflicts = new Map((staging ? stagedConflicts(staging) : []).map((c) => [c.channelKey, c.shapes]));
-            const digest = foldChannelHealth(eff.telemetry);
-            const lines = [bold("Fleet view — harness roster")];
-            lines.push(legend(`doctor cache: ${formatCacheAge(eff.doctorAgeMs)} · ${eff.adapters.length} adapters · ` +
-                `${eff.telemetry.length} journal rows · ↑↓ select · → expand · ← collapse · space toggle`));
-            const rows = visibleRows();
-            rows.forEach((row, i) => {
-                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
-                const h = eff.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(eff, row.adapter)?.models.length ?? 0, "model")}` : "";
-                    const deny = eff.denyAdapters.includes(row.adapter)
-                        ? ` · ${fail("denied")}${note(eff.notes?.denyAdapters?.[row.adapter])}`
-                        : "";
-                    const stagedBit = staged?.adapters.has(row.adapter) ? ` · ${warn("● staged")}` : "";
-                    lines.push(`${pointer}${marker} ${bold(row.adapter)}  ${state}${counts}${deny}${stagedBit}`);
-                    return;
-                }
-                const m = eff.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(eff, 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`)}` : "";
-                const stagedBit = staged?.channels.has(key) ? `  ${warn("● staged")}` : "";
-                const pinnedFor = conflicts.get(key);
-                const conflictBit = pinnedFor
-                    ? `  ${warn(`${GLYPHS.attention} conflict: pinned for ${pinnedFor.join(", ")}`)}`
-                    : "";
-                lines.push(`${pointer}  ${row.model.padEnd(28)} [${m.tier}] ${m.channel}  ${auth}${deny}${healthBit}${stagedBit}${conflictBit}`);
-            });
-            lines.push(...detailPanel(eff, 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

@@ -1,7 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,48 +0,0 @@
-import { type BillingChannel } from "../../adapters/types.js";
-import { type RoutingMode, type TickmarkrConfig, type Tier } from "../../config/config.js";
-import { type Shape, type Task } from "../../graph/schema.js";
-import type { RoutingProfile } from "../../route/profile.js";
-import { FleetStaging } from "../staging.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;
-    /** shared staged-changes buffer; default derives one from data.cfg — edits never leave it */
-    staging?: FleetStaging;
-};
-export type RoutingView = View & {
-    /** open the candidate inspector for a shape (default: the selected grid row) */
-    openInspector(shape?: Shape): void;
-    closeInspector(): void;
-    moveCursor(delta: number): void;
-    /** move the inspector's candidate highlight (wraps) */
-    moveInspectorCursor(delta: number): void;
-    /** stage the highlighted inspector candidate as that shape's map pin */
-    stageInspectorPin(): void;
-    /** stage a floor tier for the selected grid shape */
-    stageFloor(tier: Tier): void;
-    /** stage a prefer chain for the selected grid shape ([] clears the chain) */
-    stagePrefer(chain: string[]): void;
-    /** stage a routing mode — compiles into the preset's floor table in the buffer */
-    stageMode(mode: RoutingMode): void;
-    /** discard every staged edit (delegates to the staging model) */
-    revert(): void;
-    readonly selectedShape: Shape;
-    /** mode derived from the buffer: loaded mode, a staged preset, or "custom" — never stored */
-    readonly selectedMode: RoutingMode | "custom";
-    /** the staging model every change flows through */
-    readonly staging: FleetStaging;
-    /** the inspector's candidate rows — 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;