tumwater 0.4.0 → 0.4.2

package/dist/src/ui/tui/tui-history.js

@@ -8,21 +8,23 @@
 import { runRowCells } from "../../history/history-data.js";
 /** The pane body for a set of run rows: `time  role #run  result  duration`, then `model`
  * (between the result and the duration), and `usage` and `detail` when they carry anything,
- * joined newest-first by newlines. The cells come from history-data.ts's runRowCells, the one
- * home the CLI's table builds on too, so a null `durationMs` (the run's start sits outside
- * the scanned window) shows the em dash here the same way; an empty `model` (the start named
- * none or sat outside the window), an empty `usage` (neither tokens nor cost), and an empty
- * `detail` are omitted rather than leaving a gap. No rows renders `""`, which the pane's
- * `emptyNote` replaces. `row.result` is the string history-data.ts resolved (including a
- * joined merge verdict), never reclassified here. */
+ * joined newest-first by newlines. Both the result and the duration cells come from
+ * history-data.ts's runRowCells, the one home the CLI's table builds on too, so a run cut
+ * off at its model's context ceiling reads `no change (cut off)` here the way it does in
+ * `history`, and a null `durationMs` (the run's start sits outside the scanned window)
+ * shows the em dash the same way; an empty `model` (the start named none or sat outside
+ * the window), an empty `usage` (neither tokens nor cost), and an empty `detail` are
+ * omitted rather than leaving a gap. No rows renders `""`, which the pane's `emptyNote`
+ * replaces. The result cell goes through eventTypeLabel exactly as the CLI table's does,
+ * so a merged run's resolved verdict and a `no_change` read the same label in both. */
 export function historyPaneText(rows) {
     return rows
         .map((row) => {
-        const { duration } = runRowCells(row);
-        const parts = [row.time, `${row.role} #${row.run}`, row.result];
+        const cells = runRowCells(row);
+        const parts = [row.time, `${row.role} #${row.run}`, cells.result];
         if (row.model)
             parts.push(row.model);
-        parts.push(duration);
+        parts.push(cells.duration);
         if (row.usage)
             parts.push(row.usage);
         if (row.detail)

package/dist/src/ui/tui/tui-keys.js

@@ -4,7 +4,9 @@ import { runDoctor } from "../../doctor/doctor.js";
 import { killOrphans } from "../../doctor/doctor-orphans.js";
 import { dropBrokenPins, retireLeftovers } from "../../doctor/doctor-contention-checks.js";
 import { commitUncommittedBacklog } from "../../doctor/doctor-backlog.js";
+import { archiveFinishedOnMain } from "../../backlog/backlog-archive.js";
 import { loadConfigSafe } from "../../config/config.js";
+import { MERGE_LOCK_WAIT_MS } from "../../paths.js";
 import { commitOperatorBacklogEdit } from "../../backlog/backlog-commit.js";
 import { stampedSubject } from "../../git/commit-message.js";
 import { previewRevert, revertMergedCommit } from "../../operator/revert.js";
@@ -35,11 +37,12 @@ export function createTuiKeys(deps) {
     const { root } = deps;
     const collectPending = deps.collectPending ?? collectTeamChanges;
     const collectOverlaps = deps.collectOverlaps ?? collectChangeOverlaps;
-    const runDoctorSeam = deps.runDoctor ?? ((r, p) => runDoctor(r, undefined, undefined, p));
+    const runDoctorSeam = deps.runDoctor ?? ((r) => runDoctor(r));
     const killOrphansSeam = deps.killOrphans ?? ((r) => killOrphans(r));
     const dropBrokenPinsSeam = deps.dropBrokenPins ?? ((r) => dropBrokenPins(r));
     const retireLeftoversSeam = deps.retireLeftovers ?? ((r) => retireLeftovers(r, loadConfigSafe(r).config));
     const commitBacklogSeam = deps.commitBacklog ?? ((r) => commitUncommittedBacklog(r, loadConfigSafe(r).config));
+    const archiveBacklogSeam = deps.archiveBacklog ?? ((r) => archiveFinishedOnMain(r, { lockTimeoutMs: MERGE_LOCK_WAIT_MS }));
     const previewRevertSeam = deps.previewRevert ?? previewRevert;
     const revertCommit = deps.revertCommit ?? revertMergedCommit;
     const collectChange = deps.collectChange ?? collectRoleChange;
@@ -89,6 +92,7 @@ export function createTuiKeys(deps) {
         dropBrokenPins: dropBrokenPinsSeam,
         retireLeftovers: retireLeftoversSeam,
         commitBacklog: commitBacklogSeam,
+        archiveBacklog: archiveBacklogSeam,
         previewRevert: previewRevertSeam,
         revertCommit,
         collectChange,
@@ -108,6 +112,7 @@ export function createTuiKeys(deps) {
         refreshQueued: panes.refreshQueued,
         refreshNotes: panes.refreshNotes,
         refreshBrief: panes.refreshBrief,
+        refreshReport: panes.refreshReport,
         clearBacklogSelection: panes.clearBacklogSelection,
         applyHistorySearch: panes.applyHistorySearch,
         applyActivitySearch: panes.applyActivitySearch,

package/dist/src/ui/tui/tui-pane-activity.js

@@ -39,58 +39,70 @@ export function createActivityPane(session) {
         activityGrep = pattern;
         activityScroll = null;
     };
+    /** Ctrl+G arm: the Activity feed scopes over the same raw roster ids, so `feature-2` is its
+     * own slot; the filter reads exact role ids through eventRole. The scroll resets because its
+     * offset indexed the old (unfiltered or differently filtered) list. */
+    const activityScopeCycle = (ctx) => {
+        if (!promptLineFree(ctx.es))
+            return false;
+        const slots = [null, ...session.roleIds];
+        const slot = slots.indexOf(activityRole);
+        activityRole = slots[(slot + 1) % slots.length] ?? null;
+        activityScroll = null;
+        session.requestRender();
+        return true;
+    };
+    /** Ctrl+O arm: the Activity type/notable cycle: all → notable → first present type → … → last
+     * present type → all. `present` is built from the pre-type read (type `null`, no notable
+     * cull), so every type stays reachable once one is selected — the same reason the dashboard
+     * builds its chip set before its type filter. The scroll resets because its offset indexed
+     * the old filtered list. */
+    const activityTypeCycle = (ctx) => {
+        if (!promptLineFree(ctx.es))
+            return false;
+        const present = [...new Set(activityEvents(session.root, activityRole, activityGrep, null).map((e) => e.type))].sort();
+        const slots = [
+            { notable: false, type: null },
+            { notable: true, type: null },
+            ...present.map((t) => ({ notable: false, type: t })),
+        ];
+        const idx = slots.findIndex((s) => s.notable === activityNotable && s.type === activityType);
+        const next = slots[(idx + 1) % slots.length] ?? slots[0];
+        activityNotable = next.notable;
+        activityType = next.type;
+        activityScroll = null;
+        session.requestRender();
+        return true;
+    };
+    /** PgUp/PgDn arm: the Activity pane keeps the live tail by default; PgUp pauses follow and
+     * pages back through the loaded event tail, PgDn returns toward it and re-enables follow once
+     * the window reaches the tail. Both directions clamp to [0, total - rows], and a log with
+     * rows or fewer events stays on the tail. `rows` is the feed's window height — one body
+     * line short of eventBudget while the tally line is drawn (its paneBody twin, the
+     * `rows = Math.max(1, eventBudget - tallyLine.length)` in tui-pane.ts) — so each page
+     * advances exactly as far as the feed displays and no event is skipped or unreachable
+     * while paging. The read is the pane's own fixed tail term (and active role/text
+     * filter), so it hits readEvents' stat cache rather than rescanning the log. */
+    const activityTailPage = (page) => {
+        if (session.view !== 0)
+            return false;
+        const total = activityEvents(session.root, activityRole, activityGrep, activityType, activityNotable).length;
+        const rows = total === 0 ? session.eventBudget : Math.max(1, session.eventBudget - 1);
+        const maxStart = Math.max(0, total - rows);
+        const current = activityScroll ?? maxStart;
+        const next = stepEntryScroll(current, total, rows, page);
+        activityScroll = next >= maxStart ? null : next;
+        session.requestRender();
+        return true;
+    };
     const handleKey = (key, ctx) => {
-        if (key.ctrl && key.name === "g" && promptLineFree(ctx.es)) {
-            // The Activity feed scopes over the same raw roster ids, so `feature-2` is its own
-            // slot; the filter reads exact role ids through eventRole. The scroll resets because
-            // its offset indexed the old (unfiltered or differently filtered) list.
-            const slots = [null, ...session.roleIds];
-            const slot = slots.indexOf(activityRole);
-            activityRole = slots[(slot + 1) % slots.length] ?? null;
-            activityScroll = null;
-            session.requestRender();
-            return true;
-        }
-        if (key.ctrl && key.name === "o" && promptLineFree(ctx.es)) {
-            // The Activity type/notable cycle: all → notable → first present type → … → last present
-            // type → all. `present` is built from the pre-type read (type `null`, no notable cull), so
-            // every type stays reachable once one is selected — the same reason the dashboard builds
-            // its chip set before its type filter. The scroll resets because its offset indexed the
-            // old filtered list.
-            const present = [...new Set(activityEvents(session.root, activityRole, activityGrep, null).map((e) => e.type))].sort();
-            const slots = [
-                { notable: false, type: null },
-                { notable: true, type: null },
-                ...present.map((t) => ({ notable: false, type: t })),
-            ];
-            const idx = slots.findIndex((s) => s.notable === activityNotable && s.type === activityType);
-            const next = slots[(idx + 1) % slots.length] ?? slots[0];
-            activityNotable = next.notable;
-            activityType = next.type;
-            activityScroll = null;
-            session.requestRender();
-            return true;
-        }
+        if (key.ctrl && key.name === "g")
+            return activityScopeCycle(ctx);
+        if (key.ctrl && key.name === "o")
+            return activityTypeCycle(ctx);
         const page = pageDir(key.name);
-        if (page !== null && session.view === 0) {
-            // The Activity pane keeps the live tail by default; PgUp pauses follow and pages back
-            // through the loaded event tail, PgDn returns toward it and re-enables follow once the
-            // window reaches the tail. Both directions clamp to [0, total - rows], and a log with
-            // rows or fewer events stays on the tail. `rows` is the feed's window height — one body
-            // line short of eventBudget while the tally line is drawn (its paneBody twin, the
-            // `rows = Math.max(1, eventBudget - tallyLine.length)` in tui-pane.ts) — so each page
-            // advances exactly as far as the feed displays and no event is skipped or unreachable
-            // while paging. The read is the pane's own fixed tail term (and active role/text
-            // filter), so it hits readEvents' stat cache rather than rescanning the log.
-            const total = activityEvents(session.root, activityRole, activityGrep, activityType, activityNotable).length;
-            const rows = total === 0 ? session.eventBudget : Math.max(1, session.eventBudget - 1);
-            const maxStart = Math.max(0, total - rows);
-            const current = activityScroll ?? maxStart;
-            const next = stepEntryScroll(current, total, rows, page);
-            activityScroll = next >= maxStart ? null : next;
-            session.requestRender();
-            return true;
-        }
+        if (page !== null)
+            return activityTailPage(page);
         return false;
     };
     return {

package/dist/src/ui/tui/tui-pane-backlog.js

@@ -137,7 +137,7 @@ export function createBacklogPane(session) {
             session.flashMessage(outcome.status === "released"
                 ? `released ${kind} #${position}: ${outcome.title} (lifted ${liftedNotePhrase(outcome.lifted)})${heldTail}`
                 : outcome.status === "not_refused"
-                    ? `that ${kind} carries no Refused, Waiting for the next failure, or held-for-operator note` // vocabulary-ok: the held-for-operator note's release wording
+                    ? `that ${kind} carries no Refused note`
                     : `that ${kind} was already removed or moved — nothing released`);
         }
         catch (err) {
@@ -202,7 +202,7 @@ export function createBacklogPane(session) {
         if (key.ctrl && key.name === "r" &&
             promptLineFree(ctx.es) &&
             session.view === session.roleIds.length + 1) {
-            // Ctrl+R twice releases the Refused, Waiting-for-the-next-failure, or held-for-operator
+            // Ctrl+R twice releases the Refused
             // note on the selected plan or bug through the non-exiting core the dashboard drawer
             // uses; the title check inside tryReleaseEntry refuses a stale selection. Releasing is the
             // terminal twin of `tumwater plan|bug --release <n>`: it lifts the note, commits the file
@@ -212,8 +212,8 @@ export function createBacklogPane(session) {
                 const kind = selected.kind;
                 const position = selected.position;
                 const target = { kind, position, title: selected.picked.title };
-                if (selected.picked.hold !== "refused" && selected.picked.hold !== "waiting-for-failure" && selected.picked.hold !== "held-for-operator") { // vocabulary-ok: the held-for-operator hold's key
-                    session.flashMessage(`that ${kind} carries no Refused, Waiting for the next failure, or held-for-operator note`); // vocabulary-ok: the held-for-operator note's release wording
+                if (selected.picked.hold !== "refused") {
+                    session.flashMessage(`that ${kind} carries no Refused note`);
                 }
                 else if (session.armedRelease !== null && session.armedRelease.kind === kind && session.armedRelease.position === position) {
                     // The armed title (not the re-read one) goes to tryReleaseEntry, so an entry that

package/dist/src/ui/tui/tui-pane-ctx.js

@@ -6,6 +6,6 @@
 export function promptLineFree(es) {
     return (!es.budgetMode && !es.rolePromptFor && !es.searchMode &&
         !es.pauseEditMode && !es.queuedEditFor && !es.answerFor && !es.entryEditFor &&
-        !es.notesEditFor && !es.briefEditMode && !es.retireMode && !es.roleEnabledMode && !es.quietMode && !es.intervalMode &&
+        !es.notesEditFor && !es.briefEditMode && !es.retireMode && !es.releaseMode && !es.roleEnabledMode && !es.quietMode && !es.intervalMode &&
         !es.roleModelMode && !es.instructionsEditFor && !es.claudeReserveMode);
 }

package/dist/src/ui/tui/tui-pane-health.js

@@ -5,11 +5,13 @@ import { runManualReclaim } from "../../operator/operator-intent.js";
 import { testNotifyHook } from "../../cli/notify-command.js";
 import { resyncRootInstall, rootInstallResyncLines } from "../../build/dep-install.js";
 import { brokenPinDropLines, leftoverRetireLines } from "../../doctor/doctor-contention-checks.js";
+import { describeArchivedFile } from "../../backlog/backlog-archive.js";
+import { shortSha } from "../../text/format.js";
 import { promptLineFree } from "./tui-pane-ctx.js";
 /** The Health pane (view roleIds.length + 7) of the TUI (src/ui/tui/tui.tsx): the problems-only
- * Ctrl+O toggle, the Ctrl+P image-model re-probe, the Ctrl+A commit-backlog, and the runDoctor
- * collector it re-reads on every entry. Split out of the pane-navigation monolith; it owns the
- * problems flag and the last resolved report. */
+ * Ctrl+O toggle, the Ctrl+A commit-backlog, the Ctrl+B
+ * backlog archive, and the runDoctor collector it re-reads on every entry. Split out of the
+ * pane-navigation monolith; it owns the problems flag and the last resolved report. */
 export function createHealthPane(session) {
     // Within the Health pane (Ctrl+O), whether the cached report paints only its warn and fail
     // checks, the same problems-only trim `tumwater doctor --problems` applies. Session-only
@@ -24,16 +26,14 @@ export function createHealthPane(session) {
     // current. Extracted so both the enter half of the Ctrl+T cycle and the Ctrl+R in-place
     // refresh run the same body; a run already in flight is superseded by the new read.
     let runGen = 0;
-    // Whether a Ctrl+P re-probe is in flight, so a held key never spends a second round of probes.
-    let reprobing = false;
-    const run = (probeImages = "never") => {
+    const run = () => {
         // Generation guard: each run bumps the counter, and a resolution paints only if it is
         // the latest request's — Ctrl+R held twice, or a re-run raced with a re-entry, must not
         // let an out-of-order older resolution overwrite the newer report.
         const gen = ++runGen;
         session.paneCache = null;
         lastDoctorReport = null;
-        return session.runDoctor(session.root, probeImages).then((report) => {
+        return session.runDoctor(session.root).then((report) => {
             if (gen !== runGen || session.view !== session.roleIds.length + 7)
                 return;
             lastDoctorReport = report;
@@ -57,25 +57,6 @@ export function createHealthPane(session) {
             session.requestRender();
             return true;
         }
-        if (key.ctrl && key.name === "p" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 7) {
-            // Ctrl+P on the Health pane (mnemonic: **P**robe) is the terminal twin of `tumwater doctor
-            // --reprobe` and the dashboard's Re-probe models: it re-runs the checks with every claimed
-            // pi image-input model re-probed, spending one model call each and rewriting
-            // .tumwater/state/image-probes.json. Every other view keeps its own Ctrl+P.
-            if (reprobing) {
-                session.flashMessage("a re-probe is already running");
-                session.requestRender();
-                return true;
-            }
-            reprobing = true;
-            session.flashMessage("re-probing image-input models (one model call each) …");
-            void run("all").finally(() => {
-                reprobing = false;
-            });
-            session.paneScroll = 0;
-            session.requestRender();
-            return true;
-        }
         if (key.ctrl && key.name === "e" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 7) {
             // Ctrl+E on the Health pane runs one manual reclaim pass now — the terminal twin of the
             // dashboard disk row's reclaim button and the core `tumwater reclaim`, both reached
@@ -253,6 +234,44 @@ export function createHealthPane(session) {
             });
             return true;
         }
+        if (key.ctrl && key.name === "b" && promptLineFree(ctx.es) && (ctx.es.input ?? "") === "" && session.view === session.roleIds.length + 7) {
+            // Ctrl+B on the Health pane, pressed twice, archives the finished entries still under
+            // PLANS.md's ## Done and BUGS.md's ## Fixed into PLANS-DONE.md and BUGS-FIXED.md and
+            // commits them on the base branch — the terminal twin of `tumwater archive` and the
+            // dashboard Health card's Archive backlog, all reached through the same archiveFinished-.
+            // OnMain. The first press only arms (beginKey disarms on any other key) and flashes what
+            // a second press does; the second flashes the same lines the CLI prints, joined with
+            // "; " (the nothing line verbatim when there is nothing to archive), then re-runs the
+            // checks so the `backlog archive` row reflects the move. A failure flashes instead of
+            // killing the TUI. Ctrl+B stays the prompt-line editor's line-kill (budget editor) while
+            // text is typed or an editor holds the line, and is unbound on every other view.
+            if (!session.armedArchiveBacklog) {
+                session.archiveBacklogArmed = true;
+                session.flashMessage("press Ctrl+B again to archive the finished entries under PLANS.md ## Done and BUGS.md ## Fixed — any other key keeps them");
+                session.requestRender();
+                return true;
+            }
+            session.flashMessage("archiving finished backlog entries …");
+            session.requestRender();
+            void session.archiveBacklog(session.root).then((outcome) => {
+                if (outcome.status === "nothing") {
+                    session.flashMessage("nothing to archive: PLANS.md ## Done and BUGS.md ## Fixed hold no finished entries");
+                }
+                else if (outcome.status === "skipped") {
+                    session.flashMessage(`nothing archived: ${outcome.reason}`);
+                }
+                else {
+                    session.flashMessage([...outcome.moved.map(describeArchivedFile), `committed ${shortSha(outcome.commit)}`].join("; "));
+                }
+                void run();
+                session.paneScroll = 0;
+                session.requestRender();
+            }, (err) => {
+                session.flashError(err);
+                session.requestRender();
+            });
+            return true;
+        }
         if (key.ctrl && key.name === "o" && promptLineFree(ctx.es) && session.view === session.roleIds.length + 7) {
             // Ctrl+O on the Health pane toggles the problems-only view (mnemonic: **O**nly
             // problems) — the same warn/fail trim `tumwater doctor --problems` applies — so an