tickmarkr 1.66.0 → 1.67.0

package/dist/tui/save.js

@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, globalConfigDir, loadConfigWithMode, readOverlayFile, repoOverlayPath, repoOverlayYaml, unifiedYamlDiff, } from "../config/config.js";
+import { isRunLockLive } from "../run/lock.js";
+/** Notice surfaced in the save modal whenever a run lock is live. */
+export const RELOAD_GUARD_NOTICE = "reload guard: a live run is active; the running daemon will not see these changes until it reloads";
+function overlayPath(repoRoot, target, globalDir) {
+    return target === "repo"
+        ? repoOverlayPath(repoRoot)
+        : join(globalDir ?? globalConfigDir(), "config.yaml");
+}
+function currentOverlayText(path) {
+    return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+function computeAfterBytes(target, loaded, staged, repoRoot, globalDir) {
+    const path = overlayPath(repoRoot, target, globalDir);
+    const existing = readOverlayFile(path);
+    // Reuse the existing fleet serializer and diff renderer rather than inventing a parallel formatter.
+    const merged = fleetRepoOverlayFromDelta(loaded, staged, existing);
+    return repoOverlayYaml(merged);
+}
+function roundTripError(target, repoRoot, after, staged, globalDir) {
+    try {
+        let effective;
+        if (target === "repo") {
+            effective = loadConfigWithMode(repoRoot, { globalDir, repoOverlayText: after });
+        }
+        else {
+            // Validate a candidate global overlay by loading with it in a scratch globalDir.
+            const scratch = mkdtempSync(join(tmpdir(), "tickmarkr-global-rt-"));
+            try {
+                writeFileSync(join(scratch, "config.yaml"), after);
+                effective = loadConfigWithMode(repoRoot, { globalDir: scratch });
+            }
+            finally {
+                try {
+                    rmSync(scratch, { recursive: true, force: true });
+                }
+                catch { /* best-effort cleanup */ }
+            }
+        }
+        const reparsed = fleetEditableFromConfig(effective.cfg);
+        if (!fleetEditableEquals(reparsed, staged)) {
+            return "round-trip mismatch: the written overlay does not re-parse to the staged state";
+        }
+        return null;
+    }
+    catch (e) {
+        return e.message;
+    }
+}
+/** Build the diff-confirm payload for the current staging delta and chosen target. */
+export function buildSaveProposal(opts) {
+    const path = overlayPath(opts.repoRoot, opts.target, opts.globalDir);
+    const before = currentOverlayText(path);
+    const after = computeAfterBytes(opts.target, opts.loaded, opts.staged, opts.repoRoot, opts.globalDir);
+    const diff = unifiedYamlDiff(before, after, path);
+    const loadError = roundTripError(opts.target, opts.repoRoot, after, opts.staged, opts.globalDir);
+    return {
+        target: opts.target,
+        targetPath: path,
+        before,
+        after,
+        diff,
+        liveRun: isRunLockLive(opts.repoRoot),
+        loadError,
+    };
+}
+function atomicWrite(path, bytes) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    // The sibling temp keeps rename(2) on one filesystem: readers see old or new bytes, never a partial overlay.
+    const tmp = join(dir, `.tickmarkr-save-${randomUUID()}.tmp`);
+    try {
+        writeFileSync(tmp, bytes);
+        renameSync(tmp, path);
+    }
+    catch (e) {
+        rmSync(tmp, { force: true }); // a failed rename must not leave a partial candidate behind
+        throw e;
+    }
+}
+/** Confirm and execute the write for the chosen target. */
+export function confirmSave(opts) {
+    const proposal = buildSaveProposal(opts);
+    if (proposal.loadError) {
+        return { kind: "refused", reason: proposal.loadError };
+    }
+    if (proposal.before === proposal.after) {
+        return { kind: "declined" };
+    }
+    atomicWrite(proposal.targetPath, proposal.after);
+    return { kind: "written", path: proposal.targetPath };
+}

package/dist/tui/staging.d.ts

@@ -0,0 +1,29 @@
+import { type FleetEditable } from "../config/config.js";
+/** One in-memory edit to the buffered fleet state. */
+export type FleetEdit = (buffer: FleetEditable) => void;
+/**
+ * Staged-changes buffer for the Fleet Studio write path.
+ *
+ * - The loaded state is captured at construction and never mutated.
+ * - Edits apply to an in-memory buffer only.
+ * - `revert()` discards the buffer and restores the loaded state.
+ * - The delta is computed through the existing `fleetEditableEquals` comparison.
+ * - No code path in this module writes to disk.
+ */
+export declare class FleetStaging {
+    private readonly loaded;
+    private buffer;
+    constructor(loaded: FleetEditable);
+    /** Read-only snapshot of the originally loaded state. */
+    get loadedState(): FleetEditable;
+    /** Current buffered (possibly edited) state. */
+    get current(): FleetEditable;
+    /** Apply an edit to the buffer. Never touches disk. */
+    apply(edit: FleetEdit): void;
+    /** Discard all buffered edits and restore the loaded state. */
+    revert(): void;
+    /** True when the buffer differs from the loaded state. */
+    get isDirty(): boolean;
+    /** Number of distinct staged changes vs the loaded state. */
+    get changeCount(): number;
+}

package/dist/tui/staging.js

@@ -0,0 +1,78 @@
+import { fleetEditableEquals } from "../config/config.js";
+/**
+ * Staged-changes buffer for the Fleet Studio write path.
+ *
+ * - The loaded state is captured at construction and never mutated.
+ * - Edits apply to an in-memory buffer only.
+ * - `revert()` discards the buffer and restores the loaded state.
+ * - The delta is computed through the existing `fleetEditableEquals` comparison.
+ * - No code path in this module writes to disk.
+ */
+export class FleetStaging {
+    loaded;
+    buffer;
+    constructor(loaded) {
+        this.loaded = structuredClone(loaded);
+        this.buffer = structuredClone(loaded);
+    }
+    /** Read-only snapshot of the originally loaded state. */
+    get loadedState() {
+        return structuredClone(this.loaded);
+    }
+    /** Current buffered (possibly edited) state. */
+    get current() {
+        return structuredClone(this.buffer);
+    }
+    /** Apply an edit to the buffer. Never touches disk. */
+    apply(edit) {
+        edit(this.buffer);
+    }
+    /** Discard all buffered edits and restore the loaded state. */
+    revert() {
+        this.buffer = structuredClone(this.loaded);
+    }
+    /** True when the buffer differs from the loaded state. */
+    get isDirty() {
+        return !fleetEditableEquals(this.loaded, this.buffer);
+    }
+    /** Number of distinct staged changes vs the loaded state. */
+    get changeCount() {
+        return fleetEditableDeltaCount(this.loaded, this.buffer);
+    }
+}
+/** Count changed leaves using the same equality semantics as `fleetEditableEquals`. */
+function fleetEditableDeltaCount(initial, edited) {
+    let count = 0;
+    if (JSON.stringify(initial.denyAdapters) !== JSON.stringify(edited.denyAdapters)) {
+        count += 1;
+    }
+    if (JSON.stringify(initial.denyModels) !== JSON.stringify(edited.denyModels)) {
+        count += 1;
+    }
+    const mapKeys = new Set([...Object.keys(initial.map), ...Object.keys(edited.map)]);
+    for (const shape of mapKeys) {
+        if (JSON.stringify(initial.map[shape]) !== JSON.stringify(edited.map[shape])) {
+            count += 1;
+        }
+    }
+    const floorKeys = new Set([...Object.keys(initial.floors), ...Object.keys(edited.floors)]);
+    for (const shape of floorKeys) {
+        if (initial.floors[shape] !== edited.floors[shape]) {
+            count += 1;
+        }
+    }
+    const adapterKeys = new Set([...Object.keys(initial.tiers), ...Object.keys(edited.tiers)]);
+    for (const adapter of adapterKeys) {
+        const modelKeys = new Set([
+            ...Object.keys(initial.tiers[adapter] ?? {}),
+            ...Object.keys(edited.tiers[adapter] ?? {}),
+        ]);
+        for (const model of modelKeys) {
+            if (JSON.stringify(initial.tiers[adapter]?.[model]) !==
+                JSON.stringify(edited.tiers[adapter]?.[model])) {
+                count += 1;
+            }
+        }
+    }
+    return count;
+}

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;