tickmarkr 1.72.0 → 1.74.0

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

@@ -1,234 +0,0 @@
-import { channelsFromConfig } from "../../adapters/types.js";
-import { candidateRow, shapeCandidates } from "../../cli/commands/fleet-picker.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) {
-    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);
-// 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.
-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());
-    // 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];
-            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.ranked.map(rowOf) : null;
-        },
-        render: () => {
-            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 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 = 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 ? "❯" : " ";
-                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");
-            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.ranked.length === 0)
-                    lines.push("  (no routable candidates)");
-                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/dist/tui/views/runs-view.d.ts

@@ -1,70 +0,0 @@
-import { type RunGraph, type Task, type TaskStatus } from "../../graph/schema.js";
-import { type JournalEvent, type TelemetryRow, type WorkerResultCause } from "../../run/journal.js";
-import { type GateState } from "../../cli/commands/status.js";
-import type { View } from "../app.js";
-export type AttemptRecord = {
-    attempt: number;
-    channel: string;
-    outcome: "clean" | "failed" | "in-flight" | "aborted";
-    /** typed worker-result failure reason when the attempt did not finish cleanly */
-    cause?: WorkerResultCause;
-    /** worker-result summary or consult-verdict reason, when present */
-    note?: string;
-};
-export type RunsTask = {
-    task: Task;
-    status: TaskStatus;
-    states: GateState[];
-    channel: string;
-    ctx?: number;
-    activity?: string;
-    attempts: AttemptRecord[];
-};
-/** Everything the Runs cockpit renders — loaded by the caller, never by the render path. */
-export type RunsViewData = {
-    runId?: string;
-    events: JournalEvent[];
-    graph: RunGraph;
-    /** Whether the journal is comparable with the loaded graph. Defaults to true. */
-    comparable?: boolean;
-    /** Per-tier per-task pricing from config, rendered ONLY through the shared costSignal formatter. */
-    pricing?: Record<string, number>;
-    /** This run's observed usage rows (telemetry.jsonl), folded per channel by the cost ticker. */
-    telemetry?: TelemetryRow[];
-};
-/** Options for creating a Runs view. Backward-compatible: plain `createRunsView(data)` still works. */
-export type RunsViewOptions = {
-    data?: RunsViewData;
-    repoRoot?: string;
-    /** Notify the caller of a single-line notice change (confirmation, refusal, progress, result). */
-    onNotice?: (message: string | null) => void;
-    /** Refresh injected data after a mutation. Called after a successful approval. */
-    reload?: () => RunsViewData | Promise<RunsViewData>;
-};
-export type RunsView = View & {
-    /** Handle a decoded key name ("up" | "down" | "a" | "y"). */
-    key(name: string): void;
-    /** Index of the cursor in the task list. */
-    cursor: number;
-    /** The currently selected task, if any. */
-    selectedTask(): RunsTask | undefined;
-    /** Promise of an in-flight approval, exposed for tests. */
-    approval?: Promise<void>;
-};
-/** Build the injected raw data into task rows. Pure function, no filesystem access. */
-export declare function foldRunsTasks(data: RunsViewData): RunsTask[];
-export type CostTickerRow = {
-    /** adapter:model */
-    key: string;
-    /** verbatim output of the shared cost-signal formatter */
-    signal: string;
-    /** distinct tasks dispatched on this channel */
-    tasks: number;
-    /** summed observed token usage for this channel; undefined when nothing was metered */
-    tokens?: number;
-};
-/** Sum observed token usage per channel for the loaded run. Dispatch events name the channel's
- *  full assignment (billing channel + tier); telemetry rows contribute the metered tokens. A
- *  telemetry-only channel degrades costSignal to "api metered" — never an invented price. */
-export declare function foldCostTicker(data: RunsViewData): CostTickerRow[];
-export declare function createRunsView(data?: RunsViewData, opts?: Omit<RunsViewOptions, "data">): RunsView;