tickmarkr 1.66.0 → 1.68.0

package/dist/tui/views/consult-dossier.js

@@ -0,0 +1,169 @@
+// T2 (v1.68): consult dossier viewer — the Runs cockpit's detail panel.
+// Lists every consult verdict recorded for the selected task (action + reason, dispatch order)
+// and expands one verdict's persisted prompt content on request. Pure render over INJECTED data:
+// this module never touches the filesystem — the caller folds journal events and loads the
+// consults/ artifacts, then hands both in. The prompt-content translator is a hand-written
+// line-oriented pass over a known narrow subset (headings, blockquotes, bullets, fenced blocks),
+// never a markdown-AST dependency. Rendered prompt lines are cached per verdict and invalidated
+// only on selection change — never re-parsed on repaint (opencode's opentui regression lesson).
+// Read-only by construction: there is no edit or delete path for a dossier or a verdict.
+import { GLYPHS, bold, dim, warn } from "../../brand.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export const DOSSIER_PLACEHOLDER = "consult dossier viewer — stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export function renderDossierPlaceholder() {
+    return `  ${DOSSIER_PLACEHOLDER}`;
+}
+const ACTIONS = ["retry", "reroute", "decompose", "human"];
+/** Fold one task's consult-verdict journal events into dossier verdicts, in dispatch order.
+ *  Pure function over injected events. opts.prompts carries the persisted prompt contents in
+ *  the same dispatch order (the caller reads the consults/ artifacts); a verdict whose artifact
+ *  was not loaded simply has no prompt. Malformed events are skipped, never fatal. */
+export function foldConsultVerdicts(events, taskId, opts = {}) {
+    const verdicts = [];
+    for (const e of events) {
+        if (e.taskId !== taskId || e.event !== "consult-verdict")
+            continue;
+        const d = e.data;
+        if (typeof d.action !== "string" || !ACTIONS.includes(d.action))
+            continue;
+        verdicts.push({
+            action: d.action,
+            ...(typeof d.reason === "string" ? { reason: d.reason } : {}),
+            ...(typeof d.notes === "string" ? { notes: d.notes } : {}),
+            ...(typeof d.guidance === "string" ? { guidance: d.guidance } : {}),
+        });
+    }
+    if (opts.prompts) {
+        for (const [i, prompt] of opts.prompts.entries()) {
+            if (verdicts[i])
+                verdicts[i].prompt = prompt;
+        }
+    }
+    return verdicts;
+}
+// ── prompt-content translator ────────────────────────────────────────────────
+// Hand-written, line-oriented, pure. Known subset only: ATX headings (# = bold, deeper = dim),
+// `> ` blockquotes (dim `│ ` bar prefix), `- `/`* ` bullets (• marker), ``` fenced blocks
+// (dim, indented), everything else passes through plain. No markdown-AST dependency.
+const HEADING_RE = /^(#{1,6})[ \t]+(.*)$/;
+const QUOTE_RE = /^>[ \t]?(.*)$/;
+const BULLET_RE = /^[-*][ \t]+(.*)$/;
+const FENCE_RE = /^\s*```/;
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export function translatePromptContent(content) {
+    const out = [];
+    let fenced = false;
+    for (const raw of content.split("\n")) {
+        const line = raw.replace(/\s+$/, "");
+        if (FENCE_RE.test(line)) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced) {
+            out.push(line.trim() ? dim(`    ${line}`) : "");
+            continue;
+        }
+        const heading = HEADING_RE.exec(line);
+        if (heading) {
+            out.push(heading[1].length === 1 ? bold(heading[2]) : dim(heading[2]));
+            continue;
+        }
+        const quote = QUOTE_RE.exec(line);
+        if (quote) {
+            out.push(dim(`│ ${quote[1]}`));
+            continue;
+        }
+        const bullet = BULLET_RE.exec(line);
+        if (bullet) {
+            out.push(`• ${bullet[1]}`);
+            continue;
+        }
+        out.push(line);
+    }
+    return out;
+}
+/** A verdict's guidance field is "imperative steps for the worker (newline-separated ok)" —
+ *  already list-shaped, so it renders as a bullet list, never a wall of prose. Pure. */
+export function renderGuidanceSteps(guidance) {
+    return guidance
+        .split(/\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => `• ${s}`);
+}
+/** The consult dossier panel. Stateful over injected data: a verdict cursor, at most one
+ *  expanded dossier, and a per-verdict render cache cleared only when the selection changes. */
+export function createConsultDossierPanel(initial, opts = {}) {
+    const translate = opts.translate ?? translatePromptContent;
+    let data = initial;
+    let cursor = 0;
+    let expanded = null;
+    // Per-verdict cached render of the expanded dossier block — parsed once, reused on every
+    // later expand of the same verdict within the same selection; never re-parsed per repaint.
+    const cache = new Map();
+    const dossierBlock = (verdict, index) => {
+        const hit = cache.get(index);
+        if (hit)
+            return hit;
+        const lines = [];
+        lines.push(dim(`── persisted prompt · consult · ${data?.taskId ?? "?"} · verdict ${index + 1} ──`));
+        if (verdict.prompt !== undefined)
+            lines.push(...translate(verdict.prompt));
+        else
+            lines.push(dim("(no persisted prompt content recorded for this verdict)"));
+        lines.push(`action: ${verdict.action}`);
+        const steps = verdict.guidance ? renderGuidanceSteps(verdict.guidance) : [];
+        if (steps.length > 0) {
+            lines.push("guidance:");
+            for (const s of steps)
+                lines.push(`  ${s}`);
+        }
+        cache.set(index, lines);
+        return lines;
+    };
+    return {
+        get expandedIndex() {
+            return expanded;
+        },
+        select(next) {
+            data = next;
+            cursor = 0;
+            expanded = null;
+            cache.clear();
+        },
+        key(name) {
+            if (!data || data.verdicts.length === 0)
+                return;
+            if (name === "up")
+                cursor = Math.max(cursor - 1, 0);
+            else if (name === "down")
+                cursor = Math.min(cursor + 1, data.verdicts.length - 1);
+            else if (name === "enter")
+                expanded = expanded === cursor ? null : cursor;
+        },
+        render() {
+            if (!data)
+                return [];
+            if (data.verdicts.length === 0) {
+                return [
+                    `  no consult verdicts recorded for ${data.taskId} — every attempt finished without needing a consult.`,
+                ];
+            }
+            const lines = [];
+            data.verdicts.forEach((verdict, i) => {
+                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
+                // Consult actions are not pass/fail: human → warn (needs the operator), the rest plain.
+                const actionWord = verdict.action === "human" ? warn(verdict.action) : verdict.action;
+                const reason = verdict.reason ?? verdict.notes;
+                const hint = dim(i === expanded ? "[enter: collapse]" : "[enter: expand]");
+                lines.push(`  ${pointer}${i + 1}. ${actionWord}${reason ? ` — ${reason}` : ""}  ${hint}`);
+                if (i === expanded) {
+                    for (const l of dossierBlock(verdict, i))
+                        lines.push(`     ${l}`);
+                }
+            });
+            return lines;
+        },
+    };
+}

package/dist/tui/views/diff-modal.d.ts

@@ -0,0 +1,9 @@
+import { type SaveTarget } from "../save.js";
+export type DiffModalProps = {
+    target: SaveTarget;
+    targetPath: string;
+    diff: string;
+    liveRun: boolean;
+};
+/** Render the save-confirmation modal: header names the target path, body shows the exact overlay diff. */
+export declare function renderDiffModal(props: DiffModalProps): string[];

package/dist/tui/views/diff-modal.js

@@ -0,0 +1,19 @@
+import { bold, dim, fail, legend } from "../../brand.js";
+import { RELOAD_GUARD_NOTICE } from "../save.js";
+/** Render the save-confirmation modal: header names the target path, body shows the exact overlay diff. */
+export function renderDiffModal(props) {
+    const lines = [];
+    lines.push(bold(`Save overlay — ${props.targetPath} (${props.target === "repo" ? "repository" : "global"} target)`));
+    lines.push(legend("t toggle target · y confirm · n/esc cancel"));
+    if (props.liveRun) {
+        lines.push(fail(RELOAD_GUARD_NOTICE));
+    }
+    lines.push(dim("─ diff ─"));
+    if (props.diff) {
+        lines.push(...props.diff.trimEnd().split("\n"));
+    }
+    else {
+        lines.push(dim("(no overlay changes)"));
+    }
+    return lines;
+}

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

@@ -2,6 +2,7 @@ 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";
+import type { FleetStaging } from "../staging.js";
 /** One discovered adapter and its classified models (cfg.tiers via channels()). */
 export type FleetRosterEntry = {
     adapter: string;
@@ -65,5 +66,26 @@ export type FleetView = View & {
     expanded(adapter: string): boolean;
     /** channelKey of the cursor's channel, or null when the cursor sits on an adapter row. */
     selectedChannel(): string | null;
+    /** Stage a deny⇄allow toggle for one adapter into the shared buffer. No-op without staging. */
+    toggleDenyAdapter(adapter: string): void;
+    /** Stage a deny⇄allow toggle for one channel ("adapter:model"). No-op without staging. */
+    toggleDenyChannel(channelKey: string): void;
+    /** Stage a tier override for one channel ("adapter:model"). No-op without staging. */
+    stageTierOverride(channelKey: string, tier: Tier): void;
 };
-export declare function createFleetView(data?: FleetViewData): FleetView;
+/** A channel that is denied in the staged buffer while a routing.map pin still points at it —
+ *  the fleet view stages the deny, the routing view stages the pin, and BOTH are read out of the
+ *  one shared staging model, so either view surfaces the same conflict set. */
+export type StagedConflict = {
+    /** channelKey ("adapter:model") that is both denied and pinned in the buffer. */
+    channelKey: string;
+    /** shapes whose pin the deny would dead-end (deny wins over pin in saved config). */
+    shapes: string[];
+};
+/** 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 declare function stagedConflicts(staging: FleetStaging): StagedConflict[];
+export declare function createFleetView(data?: FleetViewData, staging?: FleetStaging): FleetView;

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

@@ -1,4 +1,4 @@
-import { GLYPHS, bold, dim, fail, legend } from "../../brand.js";
+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);
@@ -55,6 +55,73 @@ export function foldChannelHealth(rows) {
         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)
@@ -114,7 +181,7 @@ function digestLine(d, noun) {
     parts.push(`${d.quotaFailovers} quota failover${d.quotaFailovers === 1 ? "" : "s"}`);
     return `  journals: ${parts.join(" · ")}`;
 }
-export function createFleetView(data) {
+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;
@@ -162,43 +229,70 @@ export function createFleetView(data) {
             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 digest = foldChannelHealth(data.telemetry);
+            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(data.doctorAgeMs)} · ${data.adapters.length} adapters · ` +
-                `${data.telemetry.length} journal rows · ↑↓ select · → expand · ← collapse · space toggle`));
+            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 = data.health[row.adapter];
+                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(data, row.adapter)?.models.length ?? 0, "model")}` : "";
-                    const deny = data.denyAdapters.includes(row.adapter)
-                        ? ` · ${fail("denied")}${note(data.notes?.denyAdapters?.[row.adapter])}`
+                    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])}`
                         : "";
-                    lines.push(`${pointer}${marker} ${bold(row.adapter)}  ${state}${counts}${deny}`);
+                    const stagedBit = staged?.adapters.has(row.adapter) ? ` · ${warn("● staged")}` : "";
+                    lines.push(`${pointer}${marker} ${bold(row.adapter)}  ${state}${counts}${deny}${stagedBit}`);
                     return;
                 }
-                const m = data.adapters.find((a) => a.adapter === row.adapter)?.models.find((mm) => mm.model === row.model);
+                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(data, row.adapter, 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`)}` : "";
-                lines.push(`${pointer}  ${row.model.padEnd(28)} [${m.tier}] ${m.channel}  ${auth}${deny}${healthBit}`);
+                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(data, digest, rows[cursor]));
+            lines.push(...detailPanel(eff, digest, rows[cursor]));
             return lines;
         },
     };

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

@@ -1,7 +1,8 @@
 import { type BillingChannel } from "../../adapters/types.js";
-import { type RoutingMode, type TickmarkrConfig } from "../../config/config.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;
@@ -15,14 +16,32 @@ export type RoutingViewDeps = {
     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 read-only candidate inspector for a shape (default: the selected grid row) */
+    /** 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;
-    /** the inspector's candidate rows — exactly the picker's candidateRow strings, in rank order */
+    /** 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;