tickmarkr 1.66.0 → 1.67.0

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

@@ -1,7 +1,8 @@
 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 { DEFAULT_CONFIG, fleetEditableFromConfig, INTEGRITY_FLOOR_SHAPES, loadConfigWithMode, ROUTING_MODES, TIER_RANK, } from "../../config/config.js";
 import { SHAPES } from "../../graph/schema.js";
+import { FleetStaging } from "../staging.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) {
@@ -22,6 +23,43 @@ export function routingPreviewTask(shape) {
     };
 }
 const isIntegrity = (shape) => INTEGRITY_FLOOR_SHAPES.includes(shape);
+// Staged-cell glyph — the same ● the shell status bar counts staged changes with (app.ts).
+const STAGED_MARK = "●";
+const lowerTier = (t) => (t === "frontier" ? "mid" : "cheap");
+const maxTier = (a, b) => (TIER_RANK[a] >= TIER_RANK[b] ? a : b);
+// config.ts presetFloor mirrored (module-private there): a mode compiles into floors at load,
+// so staging a mode stages exactly this table.
+function presetFloor(mode, shape) {
+    const dflt = DEFAULT_CONFIG.routing.floors[shape] ?? "cheap";
+    if (mode === "partner-led")
+        return "frontier";
+    if (mode === "staff-led")
+        return maxTier(lowerTier(dflt), isIntegrity(shape) ? "frontier" : "cheap");
+    return dflt;
+}
+function floorsEqual(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of keys)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+/** The header mode is DERIVED from the buffer, never stored: clean floors show the loaded mode;
+ *  floors matching a preset show that mode (staged); anything else reads "custom". */
+function deriveMode(loadedMode, loaded, buffer) {
+    if (floorsEqual(loaded.floors, buffer.floors))
+        return { mode: loadedMode, staged: false };
+    for (const mode of ROUTING_MODES) {
+        if (SHAPES.every((s) => buffer.floors[s] === presetFloor(mode, s)))
+            return { mode, staged: true };
+    }
+    return { mode: "custom", staged: true };
+}
+/** The config the router would see with the staged policy applied: map + floors ride the buffer
+ *  (deny/tier edits are the fleet view's lane, T3). The buffer snapshot is already detached. */
+function effectiveConfig(cfg, buffer) {
+    return { ...cfg, routing: { ...cfg.routing, map: buffer.map, floors: buffer.floors } };
+}
 // 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.
@@ -37,60 +75,158 @@ function loadDefaultData(repoRoot) {
 }
 export function createRoutingView(deps = {}) {
     const data = deps.data ?? loadDefaultData(deps.repoRoot ?? process.cwd());
+    // The one edit authority: every mutating method below is a staging.apply()/revert() over this
+    // buffer, so a staged change can never hide in private view state.
+    const staging = deps.staging ??
+        new FleetStaging(data ? fleetEditableFromConfig(data.cfg) : { denyAdapters: [], denyModels: [], tiers: {}, map: {}, floors: {} });
     let cursor = 0;
     let inspector = null;
+    const rankInspector = (shape) => {
+        if (!data)
+            return [];
+        // THE parity seam: rank through the same shared picker glue the fleet editor uses — no
+        // comparator lives here. Clean buffer ⇒ the injected config by reference (the delegation
+        // tests pin that identity); staged edits ⇒ the effective config, what the router would
+        // choose given the staged inputs.
+        const cfgNow = staging.isDirty ? effectiveConfig(data.cfg, staging.current) : data.cfg;
+        return shapeCandidates(routingPreviewTask(shape), cfgNow, data.channels, data.profile);
+    };
+    const rowOf = (c) => candidateRow(c, data?.cfg.pricing ?? {});
+    // Re-rank the open inspector after a staging mutation changed the ranking inputs.
+    const refreshInspector = () => {
+        if (!inspector)
+            return;
+        inspector.ranked = rankInspector(inspector.shape);
+        inspector.cursor = Math.min(inspector.cursor, Math.max(inspector.ranked.length - 1, 0));
+    };
     return {
         id: "routing",
         label: "Routing",
         get selectedShape() {
             return SHAPES[cursor];
         },
+        get selectedMode() {
+            const loadedMode = data?.mode ?? data?.cfg.routing.mode ?? "risk-based";
+            return deriveMode(loadedMode, staging.loadedState, staging.current).mode;
+        },
+        get staging() {
+            return staging;
+        },
         moveCursor(delta) {
             cursor = (cursor + delta + SHAPES.length) % SHAPES.length;
         },
+        moveInspectorCursor(delta) {
+            if (!inspector || inspector.ranked.length === 0)
+                return;
+            const n = inspector.ranked.length;
+            inspector.cursor = (inspector.cursor + delta + n) % n;
+        },
         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)) };
+            inspector = { shape: target, cursor: 0, ranked: rankInspector(target) };
         },
         closeInspector() {
             inspector = null;
         },
+        stageInspectorPin() {
+            if (!data || !inspector)
+                return;
+            const target = inspector.shape;
+            const chosen = inspector.ranked[inspector.cursor];
+            if (!chosen)
+                return;
+            const { adapter, model } = chosen.assignment;
+            staging.apply((buffer) => {
+                buffer.map[target] = { ...buffer.map[target], pin: { via: adapter, model } };
+            });
+            // No re-rank: shapeCandidates strips the shape's own pin from the ranking inputs.
+        },
+        stageFloor(tier) {
+            if (!data)
+                return;
+            const target = SHAPES[cursor];
+            staging.apply((buffer) => {
+                buffer.floors[target] = tier;
+            });
+            refreshInspector();
+        },
+        stagePrefer(chain) {
+            if (!data)
+                return;
+            const target = SHAPES[cursor];
+            staging.apply((buffer) => {
+                const entry = { ...buffer.map[target] };
+                if (chain.length)
+                    entry.prefer = [...chain];
+                else
+                    delete entry.prefer;
+                // an emptied entry leaves no phantom delta behind
+                if (Object.keys(entry).length)
+                    buffer.map[target] = entry;
+                else
+                    delete buffer.map[target];
+            });
+            refreshInspector();
+        },
+        stageMode(mode) {
+            if (!data)
+                return;
+            staging.apply((buffer) => {
+                for (const shape of SHAPES)
+                    buffer.floors[shape] = presetFloor(mode, shape);
+            });
+            refreshInspector();
+        },
+        revert() {
+            staging.revert();
+            refreshInspector();
+        },
         inspectorRows() {
-            return inspector ? [...inspector.rows] : null;
+            return inspector ? inspector.ranked.map(rowOf) : null;
         },
         render: () => {
-            const lines = ["Routing view — per-shape policy grid (read-only)"];
+            const lines = ["Routing view — per-shape policy grid"];
             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}`);
+            const buffer = staging.current;
+            const loaded = staging.loadedState;
+            const loadedMode = data.mode ?? cfg.routing.mode ?? "risk-based";
+            const { mode, staged: modeStaged } = deriveMode(loadedMode, loaded, buffer);
+            lines.push(`mode: ${mode}${modeStaged ? ` ${STAGED_MARK} (staged)` : ""}`);
             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 entry = buffer.map[shape];
+                const loadedEntry = loaded.map[shape];
+                const floor = buffer.floors[shape] ?? "—";
+                const floorStaged = loaded.floors[shape] !== buffer.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 pinStaged = JSON.stringify(loadedEntry?.pin ?? null) !== JSON.stringify(entry?.pin ?? null);
+                const preferStaged = JSON.stringify(loadedEntry?.prefer ?? null) !== JSON.stringify(entry?.prefer ?? null);
                 const sel = i === cursor ? "❯" : " ";
-                lines.push(`${sel} ${shape.padEnd(10)}${`${floor}${marker}`.padEnd(10)}${pin.padEnd(20)}${prefer}`);
+                const floorCell = `${floor}${marker}${floorStaged ? STAGED_MARK : ""}`.padEnd(10);
+                const pinCell = `${pin}${pinStaged ? STAGED_MARK : ""}`.padEnd(20);
+                const preferCell = `${prefer}${preferStaged ? STAGED_MARK : ""}`;
+                lines.push(`${sel} ${shape.padEnd(10)}${floorCell}${pinCell}${preferCell}`);
             }
             lines.push("* integrity set: never below frontier");
-            lines.push(`pick: ${SHAPES[cursor]} — enter opens the candidate inspector (read-only)`);
+            if (staging.isDirty)
+                lines.push(`${STAGED_MARK} staged — not saved`);
+            lines.push(`pick: ${SHAPES[cursor]} — enter opens the candidate inspector`);
             if (inspector) {
                 lines.push(`─ candidates: ${inspector.shape} — the fleet picker ranking for the same inputs ──`);
-                if (inspector.rows.length === 0)
+                if (inspector.ranked.length === 0)
                     lines.push("  (no routable candidates)");
-                for (const [j, row] of inspector.rows.entries()) {
-                    lines.push(`${j === 0 ? "❯ " : "  "}${row}`);
+                for (const [j, c] of inspector.ranked.entries()) {
+                    lines.push(`${j === inspector.cursor ? "❯ " : "  "}${rowOf(c)}`);
                 }
+                lines.push("select stages the highlighted candidate as this shape's pin");
             }
             return lines;
         },

package/package.json

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