tickmarkr 1.66.0 → 1.68.0

package/dist/tui/app.js

@@ -3,14 +3,34 @@ import { createFleetView } from "./views/fleet-view.js";
 import { createPreviewView } from "./views/preview-view.js";
 import { createProfileView } from "./views/profile-view.js";
 import { createRoutingView } from "./views/routing-view.js";
-const MUTATION_KEYS = ["r", "s", "m", "return"];
+import { createRunsView } from "./views/runs-view.js";
+import { renderDiffModal } from "./views/diff-modal.js";
+import { buildSaveProposal, confirmSave } from "./save.js";
+import { FleetStaging } from "./staging.js";
+const MUTATION_KEYS = ["r", "m", "return"];
 const READONLY_NOTICE = "read-only in v1.66 — write path ships in v1.67";
+function emptyFleetEditable() {
+    return {
+        denyAdapters: [],
+        denyModels: [],
+        tiers: {},
+        map: {},
+        floors: {},
+    };
+}
 export class StudioApp {
     engine;
     views;
     active = 0;
     showingHelp = false;
+    confirmingQuit = false;
+    showingSave = false;
+    saveTarget = "repo";
+    saveProposal = null;
     notice = null;
+    staging;
+    repoRoot;
+    globalDir;
     _lines = [];
     resolveExit = null;
     exited;
@@ -20,7 +40,10 @@ export class StudioApp {
             output: opts.output,
             onResize: () => this.paint(),
         });
-        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView()];
+        this.repoRoot = opts.repoRoot ?? process.cwd();
+        this.globalDir = opts.globalDir;
+        this.staging = new FleetStaging(opts.loaded ?? emptyFleetEditable());
+        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView(), createRunsView()];
         this.exited = new Promise((resolve) => {
             this.resolveExit = resolve;
         });
@@ -47,33 +70,186 @@ export class StudioApp {
             this.resolveExit = null;
         }
     }
+    /** Apply an edit to the staging buffer and repaint. Intended as the test seam and future edit hook. */
+    stageEdit(edit) {
+        this.staging.apply(edit);
+        this.paint();
+    }
+    get isModalOpen() {
+        return this.showingHelp || this.confirmingQuit || this.showingSave;
+    }
     bindKeys() {
         // view switching
         // Tab is decoded as the raw "\t" sequence by the micro-engine.
-        this.engine.key("\t", () => this.setView((this.active + 1) % this.views.length));
+        this.engine.key("\t", () => {
+            if (!this.isModalOpen)
+                this.setView((this.active + 1) % this.views.length);
+        });
         for (let i = 1; i <= this.views.length; i++) {
             const idx = i - 1;
-            this.engine.key(String(i), () => this.setView(idx));
+            this.engine.key(String(i), () => {
+                if (!this.isModalOpen)
+                    this.setView(idx);
+            });
+        }
+        // per-view navigation
+        for (const name of ["up", "down"]) {
+            this.engine.key(name, () => {
+                if (!this.isModalOpen)
+                    this.forwardViewKey(name);
+            });
         }
         // help overlay
         this.engine.key("?", () => {
-            this.showingHelp = true;
-            this.paint();
-        });
-        // dismissal / quit
-        this.engine.key("escape", () => {
-            if (this.showingHelp) {
-                this.showingHelp = false;
+            if (!this.confirmingQuit && !this.showingSave) {
+                this.showingHelp = true;
                 this.paint();
             }
-            else {
-                this.stop();
-            }
         });
-        this.engine.key("q", () => this.stop());
-        // mutation keys — read-only until the v1.67 write path
+        // dismissal / quit
+        this.engine.key("escape", () => this.handleEscape());
+        this.engine.key("q", () => this.handleQuit());
+        // revert staged changes
+        this.engine.key("u", () => this.handleRevert());
+        // save modal
+        this.engine.key("s", () => this.handleSaveOpen());
+        this.engine.key("t", () => this.handleSaveToggle());
+        // quit-confirmation / save-confirmation answers
+        this.engine.key("y", () => this.handleConfirm());
+        this.engine.key("n", () => this.handleCancel());
+        // remaining mutation keys — read-only until wired
         for (const key of MUTATION_KEYS) {
-            this.engine.key(key, () => this.showNotice());
+            this.engine.key(key, () => {
+                if (!this.isModalOpen)
+                    this.showNotice();
+            });
+        }
+    }
+    handleEscape() {
+        if (this.showingHelp) {
+            this.showingHelp = false;
+            this.paint();
+        }
+        else if (this.showingSave) {
+            this.closeSave(false);
+        }
+        else if (this.confirmingQuit) {
+            this.confirmingQuit = false;
+            this.paint();
+        }
+        else if (this.staging.isDirty) {
+            this.confirmingQuit = true;
+            this.paint();
+        }
+        else {
+            this.stop();
+        }
+    }
+    handleQuit() {
+        if (this.showingHelp || this.showingSave)
+            return; // modals block q
+        if (this.confirmingQuit) {
+            this.stop();
+            return;
+        }
+        if (this.staging.isDirty) {
+            this.confirmingQuit = true;
+            this.paint();
+        }
+        else {
+            this.stop();
+        }
+    }
+    handleSaveOpen() {
+        if (this.isModalOpen)
+            return;
+        if (!this.staging.isDirty) {
+            this.notice = "no staged changes";
+            this.paint();
+            return;
+        }
+        this.showingSave = true;
+        this.saveTarget = "repo";
+        this.saveProposal = buildSaveProposal({
+            repoRoot: this.repoRoot,
+            loaded: this.staging.loadedState,
+            staged: this.staging.current,
+            target: this.saveTarget,
+            globalDir: this.globalDir,
+        });
+        this.paint();
+    }
+    handleSaveToggle() {
+        if (!this.showingSave)
+            return;
+        this.saveTarget = this.saveTarget === "repo" ? "global" : "repo";
+        this.saveProposal = buildSaveProposal({
+            repoRoot: this.repoRoot,
+            loaded: this.staging.loadedState,
+            staged: this.staging.current,
+            target: this.saveTarget,
+            globalDir: this.globalDir,
+        });
+        this.paint();
+    }
+    handleConfirm() {
+        if (this.showingSave) {
+            this.executeSave();
+            return;
+        }
+        if (this.confirmingQuit) {
+            this.stop();
+        }
+    }
+    handleCancel() {
+        if (this.showingSave) {
+            this.closeSave(false);
+            return;
+        }
+        if (this.confirmingQuit) {
+            this.confirmingQuit = false;
+            this.paint();
+        }
+    }
+    executeSave() {
+        if (!this.saveProposal)
+            return;
+        const result = confirmSave({
+            repoRoot: this.repoRoot,
+            loaded: this.staging.loadedState,
+            staged: this.staging.current,
+            target: this.saveTarget,
+            globalDir: this.globalDir,
+        });
+        if (result.kind === "written") {
+            this.staging = new FleetStaging(this.staging.current);
+            this.closeSave(true, `wrote ${result.path}`);
+        }
+        else if (result.kind === "refused") {
+            this.closeSave(true, `save refused: ${result.reason}`);
+        }
+        else {
+            this.closeSave(false);
+        }
+    }
+    closeSave(notify, message) {
+        this.showingSave = false;
+        this.saveProposal = null;
+        if (notify && message)
+            this.notice = message;
+        this.paint();
+    }
+    handleRevert() {
+        if (this.isModalOpen)
+            return;
+        if (this.staging.isDirty) {
+            this.staging.revert();
+            this.notice = null;
+            this.paint();
+        }
+        else {
+            this.notice = "no staged changes";
+            this.paint();
         }
     }
     setView(idx) {
@@ -82,6 +258,10 @@ export class StudioApp {
         this.notice = null;
         this.paint();
     }
+    forwardViewKey(name) {
+        this.views[this.active]?.key?.(name);
+        this.paint();
+    }
     showNotice() {
         this.notice = READONLY_NOTICE;
         this.paint();
@@ -97,6 +277,17 @@ export class StudioApp {
         if (this.showingHelp) {
             lines.push(...this.renderHelp());
         }
+        else if (this.showingSave && this.saveProposal) {
+            lines.push(...renderDiffModal({
+                target: this.saveProposal.target,
+                targetPath: this.saveProposal.targetPath,
+                diff: this.saveProposal.diff,
+                liveRun: this.saveProposal.liveRun,
+            }));
+        }
+        else if (this.confirmingQuit) {
+            lines.push(...this.renderQuitConfirm());
+        }
         else {
             const view = this.views[this.active];
             lines.push(...view.render({ cols, rows: Math.max(rows - 2, 1) }));
@@ -104,6 +295,7 @@ export class StudioApp {
         if (this.notice) {
             lines.push(this.notice);
         }
+        lines.push(this.renderStatusBar());
         return lines;
     }
     renderTabBar() {
@@ -115,16 +307,28 @@ export class StudioApp {
         }
         return parts.join(" ");
     }
+    renderStatusBar() {
+        if (this.staging.isDirty) {
+            const n = this.staging.changeCount;
+            return `● ${n} staged change${n === 1 ? "" : "s"}`;
+        }
+        return "no staged changes";
+    }
     renderHelp() {
         return [
             "Key bindings",
-            "1-4      switch view",
+            "1-5      switch view",
             "tab      cycle views",
             "?        show this help",
             "esc / q  quit",
+            "u        revert staged changes",
             "r        re-probe (read-only)",
-            "s        save (read-only)",
+            "s        save",
             "m        mode (read-only)",
         ];
     }
+    renderQuitConfirm() {
+        const n = this.staging.changeCount;
+        return [`Quit with ${n} staged change${n === 1 ? "" : "s"}? (y/n)`];
+    }
 }

package/dist/tui/save.d.ts

@@ -0,0 +1,38 @@
+import { type FleetEditable } from "../config/config.js";
+export type SaveTarget = "repo" | "global";
+/** Notice surfaced in the save modal whenever a run lock is live. */
+export declare const RELOAD_GUARD_NOTICE = "reload guard: a live run is active; the running daemon will not see these changes until it reloads";
+export type SaveProposal = {
+    target: SaveTarget;
+    targetPath: string;
+    before: string;
+    after: string;
+    diff: string;
+    liveRun: boolean;
+    loadError: string | null;
+};
+export type SaveResult = {
+    kind: "written";
+    path: string;
+} | {
+    kind: "declined";
+} | {
+    kind: "refused";
+    reason: string;
+};
+/** Build the diff-confirm payload for the current staging delta and chosen target. */
+export declare function buildSaveProposal(opts: {
+    repoRoot: string;
+    loaded: FleetEditable;
+    staged: FleetEditable;
+    target: SaveTarget;
+    globalDir?: string;
+}): SaveProposal;
+/** Confirm and execute the write for the chosen target. */
+export declare function confirmSave(opts: {
+    repoRoot: string;
+    loaded: FleetEditable;
+    staged: FleetEditable;
+    target: SaveTarget;
+    globalDir?: string;
+}): SaveResult;

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/consult-dossier.d.ts

@@ -0,0 +1,49 @@
+import type { ConsultVerdict } from "../../run/consult.js";
+import type { JournalEvent } from "../../run/journal.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export declare const DOSSIER_PLACEHOLDER = "consult dossier viewer \u2014 stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export declare function renderDossierPlaceholder(): string;
+export type ConsultAction = ConsultVerdict["action"];
+/** One recorded consult verdict, with its persisted prompt content injected by the caller. */
+export interface DossierVerdict {
+    action: ConsultAction;
+    reason?: string;
+    notes?: string;
+    guidance?: string;
+    /** Persisted prompt content (the consults/<task>-<n>.md artifact), loaded by the caller. */
+    prompt?: string;
+}
+/** Everything the dossier panel renders — loaded by the caller, never by the render path. */
+export interface ConsultDossierData {
+    taskId: string;
+    /** Verdicts in dispatch order (journal order). */
+    verdicts: DossierVerdict[];
+}
+export interface ConsultDossierPanel {
+    /** Change the selected task. Any selection change invalidates every cached prompt render. */
+    select(data: ConsultDossierData | undefined): void;
+    /** "up"/"down" move the verdict cursor; "enter" toggles the selected verdict's dossier. */
+    key(name: string): void;
+    /** Render the panel body lines (chrome/divider lines are the host view's job). */
+    render(): string[];
+    /** Index of the expanded verdict, or null when collapsed. */
+    readonly expandedIndex: number | null;
+}
+/** 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 declare function foldConsultVerdicts(events: JournalEvent[], taskId: string, opts?: {
+    prompts?: string[];
+}): DossierVerdict[];
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export declare function translatePromptContent(content: string): string[];
+/** 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 declare function renderGuidanceSteps(guidance: string): string[];
+/** 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 declare function createConsultDossierPanel(initial?: ConsultDossierData, opts?: {
+    translate?: (content: string) => string[];
+}): ConsultDossierPanel;