tickmarkr 1.66.0 → 1.67.0

package/dist/cli/commands/run.js

@@ -4,6 +4,7 @@ import { ROUTING_MODES } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
+import { isRunLockLive } from "../../run/lock.js";
 import { route, NO_EXPLORE_ENV } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
 import { ttyVisual } from "../../adapters/model-lints.js";
@@ -65,6 +66,14 @@ export async function run(argv, cwd = process.cwd()) {
             throw new Error(`--route-strict: refusing to dispatch — ${conflict}`);
         console.warn(`tickmarkr: !! ${conflict}`);
     }
+    // OBS-107 (v1.67 T5): advisory only — a stale compiled graph with prior terminal statuses and no
+    // live daemon will otherwise finish with zero work and confuse the operator. The recompile remedy
+    // is named; dispatch proceeds unchanged.
+    const TERMINAL_STATUSES = ["done", "failed", "human"];
+    if (graph.tasks.some((t) => TERMINAL_STATUSES.includes(t.status)) && !isRunLockLive(cwd)) {
+        console.warn("tickmarkr: compiled graph carries terminal statuses from a prior run and no daemon is active — "
+            + "run `tickmarkr compile <src>` to recompile; proceeding with stale graph");
+    }
     const noExplore = !!values["no-explore"];
     const exploreCtx = noExplore ? { noExplore } : undefined;
     if (noExplore)

package/dist/cli/commands/status.js

@@ -60,8 +60,6 @@ const GATE_STATE_TOKEN = { pass: ok, fail, skip: dim, open: dim };
 const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
     ? GATE_STATE_TOKEN[states[i]](gateBox(states[i], true))
     : `${GATE_KEYS[gate]}${gateBox(states[i], false)}`).join(" ");
-// plain (uncolored) cell width for column math — ANSI codes have zero display width
-const gateChainWidth = (unicode) => GATE_NAMES.reduce((w, gate) => w + (unicode ? 1 : GATE_KEYS[gate].length + 3) + 1, -1);
 const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
 // plain-text form of the failed-gate words for column math; rendered with a dim dot + red names
 const failedSuffix = (states) => {
@@ -182,10 +180,13 @@ const renderFrame = (cwd) => {
     const done = effective.tasks.filter((t) => t.status === "done").length;
     const cells = g.tasks.map((t) => {
         const st = replayed?.get(t.id) ?? t.status;
-        const label = starved.has(t.id) ? " starved" : activity.cells.has(t.id) ? ` ${activity.cells.get(t.id)}` : "";
+        const isStarved = starved.has(t.id);
+        const phrase = isStarved ? undefined : activity.cells.get(t.id);
+        const label = isStarved ? " starved" : phrase ? ` ${phrase}` : "";
         const channel = assignments.get(t.id) ?? "-";
-        const assignCol = contexts.has(t.id) ? `${channel}${divider}ctx ${contexts.get(t.id)}` : channel;
-        return { t, st, label, assignCol, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
+        const ctx = contexts.get(t.id);
+        const assignCol = ctx !== undefined ? `${channel}${divider}ctx ${ctx}` : channel;
+        return { t, st, label, assignCol, isStarved, phrase, channel, ctx, states: comparable ? gateStates(t, events) : defaultGateStates(t) };
     });
     if (!unicode) {
         // machine/CI surface — layout unchanged (pipes, greps, and the golden pins depend on it)
@@ -227,26 +228,39 @@ const renderFrame = (cwd) => {
     // rows: the line names task ids, and rows must stay the first id-bearing lines for grep consumers.
     const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
     const gatesLegend = legend(`   gates: ${GATE_NAMES.join(" · ")}`);
+    // Two-line card per task (operator request, v1.67): line 1 carries identity + verdict — glyph,
+    // id, goal at full width, and only SHORT status words. Line 2 carries the machinery, dim and
+    // aligned under the goal: gate chain, live activity phrase (or channel), ctx. Long channel names
+    // and activity phrases live on line 2 only, so they can never squeeze the goal or wrap line 1.
     const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
-    const stW = Math.max(...cells.map((c) => (String(c.st) + c.label + failedSuffix(c.states) + humanGateSuffix(c.t, c.st, c.states)).length));
-    const chainW = gateChainWidth(true);
-    const assignW = Math.max(...cells.map((c) => c.assignCol.length));
-    const goalW = Math.max(8, width - (5 + idW) - 2 - chainW - 2 - stW - 2 - assignW);
-    const rows = cells.map(({ t, st, label, assignCol, states }) => {
-        const goal = shortGoal(t.goal, goalW).padEnd(goalW);
+    // plain-text status suffixes for width math only — starved / failed gate names / approval hint
+    const suffixPlain = (c) => (c.isStarved ? " · starved" : "") + failedSuffix(c.states) + humanGateSuffix(c.t, c.st, c.states);
+    const stW = Math.max(...cells.map((c) => String(c.st).length + suffixPlain(c).length));
+    const avail = Math.max(8, width - (5 + idW) - 2 - stW);
+    const goals = cells.map((c) => shortGoal(c.t.goal, avail));
+    const goalW = Math.max(8, ...goals.map((s) => s.length));
+    const indent = " ".repeat(idW + 5); // line 2 starts under the goal column
+    const rows = cells.map(({ t, st, states, isStarved, phrase, channel, ctx }, i) => {
         const stWord = st === "done" ? ok(String(st)) : st === "failed" ? fail(String(st)) : st === "human" ? warn(String(st)) : String(st);
         // a fail names its gate in words right here — the one moment gate identity is needed on a row
         const f = failedGates(states);
         const human = humanGateSuffix(t, st, states);
         const statusCell = stWord +
-            (label ? (label === " starved" ? fail(label) : dim(label)) : "") +
-            (f.length ? dim(" · ") + fail(f.join(", ")) : "") +
-            (human ? dim(" · ") + warn("awaiting approval") : "") +
-            " ".repeat(stW - (String(st) + label + failedSuffix(states) + human).length);
-        return `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goal}  ${gateChain(states, true)}  ${statusCell}  ${dim(assignCol)}`)}`;
-    });
-    return [header, hr, gatesLegend, ...rows, ...nowLine].join("\n");
+            (isStarved ? dot + fail("starved") : "") +
+            (f.length ? dot + fail(f.join(", ")) : "") +
+            (human ? dot + warn("awaiting approval") : "");
+        const line1 = `  ${statusRow(taskVerdict(st), `${t.id.padEnd(idW)} ${goals[i].padEnd(goalW)}  ${statusCell}`)}`;
+        // activity already names its channel for in-flight attempts — never repeat it
+        const detail = [
+            ...(phrase ? [phrase, ...(phrase.includes(channel) || channel === "-" ? [] : [channel])] : [channel]),
+            ...(ctx !== undefined ? [`ctx ${ctx}`] : []),
+        ].join(" · ");
+        return [line1, `${indent}${gateChain(states, true)}  ${dim(detail)}`, ""];
+    }).flat();
+    if (!nowLine.length)
+        rows.pop(); // cards end blank-separated; drop the dangling one
+    return [header, hr, gatesLegend, "", ...rows, ...nowLine].join("\n");
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     // cockpit surface: banner + frame on a TTY (doctor's pattern); pipes get the bare frame

package/dist/compile/collateral.d.ts

@@ -4,6 +4,7 @@ import { type Task } from "../graph/schema.js";
  * Each line names the task id and at least one missing collateral test path.
  */
 export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
+export declare function newDirectoryLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
 /**
  * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
  * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.

package/dist/compile/collateral.js

@@ -145,20 +145,69 @@ function criteriaSymbols(acceptance) {
     }
     return [...out].sort();
 }
+const ARCH_PAGES = ["docs/codebase/ARCHITECTURE.md", "docs/codebase/STRUCTURE.md"];
+function topLevelSrcDir(file) {
+    const parts = file.replace(/^\.\//, "").replace(/\/+$/, "").split("/");
+    if (parts[0] !== "src" || parts.length < 2 || !parts[1])
+        return undefined;
+    return parts[1];
+}
+function existingSrcTopLevels(repoRoot) {
+    const out = new Set();
+    let entries;
+    try {
+        entries = readdirSync(join(repoRoot, "src"), { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (e.isDirectory())
+            out.add(e.name);
+    }
+    return out;
+}
+// OBS-108 (v1.67 T5): a task whose files[] creates a new top-level src/ directory must also
+// include the architecture pages the docs-truth suite pins. Advisory only — never blocks compile.
+export function newDirectoryLints(tasks, repoRoot) {
+    const existing = existingSrcTopLevels(repoRoot);
+    const lines = [];
+    for (const t of tasks) {
+        // OBS-22: scopeGate accepts picomatch globs; advisory warnings must agree.
+        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
+        const newDirs = new Set();
+        for (const f of t.files) {
+            const dir = topLevelSrcDir(f);
+            if (!dir || existing.has(dir))
+                continue;
+            newDirs.add(`src/${dir}/`);
+        }
+        if (!newDirs.size)
+            continue;
+        const missing = ARCH_PAGES.filter((p) => !scoped(p));
+        if (!missing.length)
+            continue;
+        const dirList = [...newDirs].sort().join(", ");
+        const dirLabel = newDirs.size > 1 ? "directories" : "directory";
+        lines.push(`${t.id}: new top-level source ${dirLabel} ${dirList} must include ${missing.join(" and ")} in files[]`);
+    }
+    return lines;
+}
 /**
  * OBS-76 class: sweep src/ for out-of-scope source files that reference a symbol the acceptance
  * criteria name — the v1.52 router.ts omission, named at plan time instead of one judge round in.
  * Advisory plan output only, same contract as collateralLints.
  */
 export function sourceScopeLints(tasks, repoRoot) {
+    const newDirLints = newDirectoryLints(tasks, repoRoot);
     const perTask = tasks
         .map((t) => ({ t, needles: criteriaSymbols(t.acceptance) }))
         .filter((x) => x.needles.length);
     if (!perTask.length)
-        return [];
+        return newDirLints;
     const srcFiles = walkCode(repoRoot, "src");
     if (!srcFiles.length)
-        return [];
+        return newDirLints;
     const read = makeReader(repoRoot);
     const lines = [];
     for (const { t, needles } of perTask) {
@@ -183,5 +232,5 @@ export function sourceScopeLints(tasks, repoRoot) {
         const tail = hits.length > MAX_HITS_PER_TASK ? " (capped)" : "";
         lines.push(`${t.id}: criteria implicate out-of-scope source not in files[]: ${listed}${tail}`);
     }
-    return lines;
+    return [...newDirLints, ...lines];
 }

package/dist/gates/run-gates.js

@@ -72,16 +72,23 @@ export async function runGates(task, ctx) {
         // worker attempt — exactly what this fix forbids; only its meta-carries-channel pattern is mirrored.
         // Straight-line single `if` — NO loop/counter/knob: exactly-once by construction (a knob is a
         // fail-closed weakening vector); a second garbage verdict fails the gate closed exactly as today.
+        // T6: exclusion mirrors consult reroute semantics — the flaked channel's whole adapter is banned, not
+        // just its exact channel key, so an outage window cannot re-select the vendor being routed around.
+        // If no other adapter is live, the exclusion degrades to a channel-level reroute within the same
+        // adapter so a single-adapter fleet still retries (matching the daemon's unknown-excludeAdapter
+        // degradation path).
         if (a.meta?.unparseable === true && typeof a.meta.judge === "string") {
             const flakedKey = a.meta.judge;
-            const candidate = ctx.channels
-                .filter((c) => channelKey(c) !== flakedKey)
+            const flakedAdapter = flakedKey.slice(0, flakedKey.indexOf(":"));
+            const pick = (pool) => pool
                 // pickReviewer's sort (review.ts:37): TIER_RANK desc, marginalCostRank asc — proven ordering; both
-                // symbols already imported by a sibling gate file. No vendor-diversity axis (the judge isn't review).
+                // symbols already imported by a sibling gate file.
                 .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
-            // ponytail: same-channel fallback when the fleet has no alternative (D-03). One judge call against a
-            // deterministic garbage source is wasted, bounded; fail-closed unchanged on a second garbage verdict.
-            const retry = candidate ?? { adapter: ctx.cfg.judge.adapter, model: ctx.cfg.judge.model };
+            const crossAdapter = pick(ctx.channels.filter((c) => c.adapter !== flakedAdapter));
+            const sameAdapter = pick(ctx.channels.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
+            // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
+            // that adapter; if the fleet has only one channel, fall back to the original judge config.
+            const retry = crossAdapter ?? sameAdapter ?? { adapter: ctx.cfg.judge.adapter, model: ctx.cfg.judge.model };
             const retryAdapter = getAdapter(retry.adapter, ctx.adapters);
             const retryJvia = ctx.via
                 // unconditional -r1 suffix: under keepPanes:forever a same-channel retry cannot collide with the

package/dist/tui/app.d.ts

@@ -1,5 +1,7 @@
 import { type OutputStream } from "../tui/engine.js";
 import type { InputStream } from "../tui/input.js";
+import type { FleetEditable } from "../config/config.js";
+import { type FleetEdit } from "./staging.js";
 export type View = {
     id: string;
     label: string;
@@ -11,13 +13,26 @@ export type View = {
 export type StudioOptions = {
     input: InputStream;
     output: OutputStream;
+    /** Loaded fleet state the buffer wraps. Defaults to an empty editable for the no-arg shell path. */
+    loaded?: FleetEditable;
+    /** Repository root used for overlay paths and live-run detection. Defaults to cwd. */
+    repoRoot?: string;
+    /** Global config directory override. */
+    globalDir?: string;
 };
 export declare class StudioApp {
     private engine;
     private views;
     private active;
     private showingHelp;
+    private confirmingQuit;
+    private showingSave;
+    private saveTarget;
+    private saveProposal;
     private notice;
+    private staging;
+    private repoRoot;
+    private globalDir;
     private _lines;
     private resolveExit;
     readonly exited: Promise<void>;
@@ -30,11 +45,25 @@ export declare class StudioApp {
     start(): void;
     /** Restore the terminal and release the input stream. */
     stop(): void;
+    /** Apply an edit to the staging buffer and repaint. Intended as the test seam and future edit hook. */
+    stageEdit(edit: FleetEdit): void;
+    private get isModalOpen();
     private bindKeys;
+    private handleEscape;
+    private handleQuit;
+    private handleSaveOpen;
+    private handleSaveToggle;
+    private handleConfirm;
+    private handleCancel;
+    private executeSave;
+    private closeSave;
+    private handleRevert;
     private setView;
     private showNotice;
     private paint;
     private buildFrame;
     private renderTabBar;
+    private renderStatusBar;
     private renderHelp;
+    private renderQuitConfirm;
 }

package/dist/tui/app.js

@@ -3,14 +3,33 @@ 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 { 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,6 +39,9 @@ export class StudioApp {
             output: opts.output,
             onResize: () => this.paint(),
         });
+        this.repoRoot = opts.repoRoot ?? process.cwd();
+        this.globalDir = opts.globalDir;
+        this.staging = new FleetStaging(opts.loaded ?? emptyFleetEditable());
         this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView()];
         this.exited = new Promise((resolve) => {
             this.resolveExit = resolve;
@@ -47,33 +69,179 @@ 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);
+            });
         }
         // 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) {
@@ -97,6 +265,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 +283,7 @@ export class StudioApp {
         if (this.notice) {
             lines.push(this.notice);
         }
+        lines.push(this.renderStatusBar());
         return lines;
     }
     renderTabBar() {
@@ -115,6 +295,13 @@ 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",
@@ -122,9 +309,14 @@ export class StudioApp {
             "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;