tumwater 0.3.0 → 0.4.0

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

@@ -43,10 +43,16 @@ export function createTuiPanes(deps) {
         session.notesClearArmed = null;
         session.armedKillOrphans = session.killOrphansArmed;
         session.killOrphansArmed = false;
+        session.armedDropBrokenPins = session.dropBrokenPinsArmed;
+        session.dropBrokenPinsArmed = false;
+        session.armedRetireLeftovers = session.retireLeftoversArmed;
+        session.retireLeftoversArmed = false;
         session.armedRevert = session.revertArmed;
         session.revertArmed = null;
         session.armedQueue = session.queueArmed;
         session.queueArmed = null;
+        session.armedReview = session.reviewArmed;
+        session.reviewArmed = null;
     };
     /** The per-key pane snapshot the editors' open arms read. */
     const editorCtx = () => {
@@ -159,6 +165,16 @@ export function createTuiPanes(deps) {
             return health.handleKey?.(key, ctx) ?? false;
         if (key.ctrl && key.name === "w")
             return history.handleKey?.(key, ctx) ?? false;
+        // Health owns Ctrl+S (drop broken pins) ahead of the pane router's fallthrough; off the
+        // Health view it falls through so the quiet-hours (Activity), trailing-window (History)
+        // and min-run-interval (Transcript) arms keep their current meanings.
+        if (key.ctrl && key.name === "s" && session.view === session.roleIds.length + 7) {
+            // On the Health view the drop-pins arm consumes Ctrl+S only on an empty prompt line; a
+            // non-empty prompt or a held editor falls through so History's trailing-window cycle still
+            // takes the key, exactly as it did before the drop-pins arm existed.
+            if (health.handleKey?.(key, ctx))
+                return true;
+        }
         if (key.ctrl && key.name === "s")
             return history.handleKey?.(key, ctx) ?? false;
         // Ctrl+P on Usage/Failures steps the report window back; every other view is History's.
@@ -170,6 +186,29 @@ export function createTuiPanes(deps) {
             return health.handleKey?.(key, ctx) ?? false;
         if (key.ctrl && key.name === "p")
             return history.handleKey?.(key, ctx) ?? false;
+        // Health owns Ctrl+A (commit-backlog) ahead of the pane router's fallthrough; the Backlog
+        // view's Ctrl+A (the answer editor) is handled by tui-editor-answer.ts, which the key
+        // dispatcher consults before this router, so this case never shadows it.
+        if (key.ctrl && key.name === "a" && session.view === session.roleIds.length + 7)
+            return health.handleKey?.(key, ctx) ?? false;
+        // Pending owns Ctrl+A on its own view (the two-step post-merge-review accept), routed after
+        // Health's so the Health commit-backlog arm keeps its view's slot.
+        if (key.ctrl && key.name === "a" && session.view === session.roleIds.length + 5)
+            return pending.handleKey?.(key, ctx) ?? false;
+        // Health owns Ctrl+U (re-sync install) ahead of the pane router's fallthrough; off the
+        // Health view it falls through so the prompt-line editor keeps Ctrl+U (kill-to-start).
+        if (key.ctrl && key.name === "u" && session.view === session.roleIds.length + 7)
+            return health.handleKey?.(key, ctx) ?? false;
+        // Health owns Ctrl+L (retire leftovers) ahead of the pane router's fallthrough; off the
+        // Health view it falls through so the Activity fallback shift (view 0) and the
+        // instructions editor on a role's Transcript keep their current meanings.
+        if (key.ctrl && key.name === "l" && session.view === session.roleIds.length + 7)
+            return health.handleKey?.(key, ctx) ?? false;
+        // History owns Ctrl+L (newest failure) after Health's; off the History view it falls
+        // through so the Activity fallback editor (view 0) and a Transcript's instructions editor
+        // (handled in the editors ahead of this router) keep their current meanings.
+        if (key.ctrl && key.name === "l")
+            return history.handleKey?.(key, ctx) ?? false;
         if (key.ctrl && key.name === "y") {
             // Ctrl+Y's transcript change-step arm (the diffstat toggle) is routed first and falls
             // through off it, so History keeps its Summary cycle on every other view.
@@ -179,12 +218,18 @@ export function createTuiPanes(deps) {
         }
         if (key.ctrl && key.name === "o") {
             // The Activity type cycle is routed first on its own view (0); on the Health view the
-            // problems-only toggle precedes the History outcome cycle, and every other view keeps
-            // the History outcome cycle.
+            // problems-only toggle precedes the History outcome cycle; on the Pending view the
+            // post-merge review state filter is routed ahead of History's outcome cycle (its own arm
+            // consumes the key on Pending); on the Backlog view the Ready-only filter is routed
+            // ahead of History's outcome cycle, and every other view keeps the History outcome cycle.
             if (session.view === 0)
                 return activity.handleKey?.(key, ctx) ?? false;
             if (session.view === session.roleIds.length + 7)
                 return health.handleKey?.(key, ctx) ?? false;
+            if (session.view === session.roleIds.length + 5)
+                return pending.handleKey?.(key, ctx) ?? false;
+            if (session.view === session.roleIds.length + 1)
+                return backlog.handleKey?.(key, ctx) ?? false;
             return history.handleKey?.(key, ctx) ?? false;
         }
         if (key.ctrl && key.name === "x") {
@@ -214,15 +259,17 @@ export function createTuiPanes(deps) {
             return backlog.handleKey?.(key, ctx) ?? false;
         }
         if (key.ctrl && key.name === "v") {
-            // The Ctrl+V arms, routed like Ctrl+X's: the History trail's revert, then the queued
-            // prompt's and the backlog entry's move-to-top — each returns false when its
-            // view/selection does not apply. The
-            // Activity attach editor's own Ctrl+V arm is guarded to view 0, so it still fires
-            // there ahead of this router.
+            // The Ctrl+V arms, routed like Ctrl+X's: the History trail's revert, the queued
+            // prompt's move-to-top, then the Pending pane's merge move-to-top, and the backlog
+            // entry's move-to-top last — each returns false when its view/selection does not
+            // apply. The Activity attach editor's own Ctrl+V arm is guarded to view 0, so it
+            // still fires there ahead of this router.
             if (history.handleKey?.(key, ctx))
                 return true;
             if (queued.handleKey?.(key, ctx))
                 return true;
+            if (pending.handleKey?.(key, ctx))
+                return true;
             return backlog.handleKey?.(key, ctx) ?? false;
         }
         const arrow = arrowDir(key.name);
@@ -310,6 +357,7 @@ export function createTuiPanes(deps) {
             activityRole: act.activityRole,
             activityGrep: act.activityGrep,
             activityType: act.activityType,
+            activityNotable: act.activityNotable,
             noteMode: tra.noteMode,
             noteCache: tra.noteCache,
             changeMode: tra.changeMode,
@@ -319,6 +367,7 @@ export function createTuiPanes(deps) {
             selectedEntry: back.selectedEntry,
             entryScroll: back.entryScroll,
             backlogGrep: back.backlogGrep,
+            backlogReadyOnly: back.backlogReadyOnly,
             scopeRole: rep.scopeRole,
             reportSince: rep.reportSince,
             reportStep: rep.reportStep,

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

@@ -2,10 +2,13 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { render as inkRender } from "ink";
 import { TuiApp } from "./tui-app.js";
 import { openQuestions } from "../../backlog/backlog.js";
-import { operatorHeldEntries, refusedEntries, stalledPlanEntries } from "../../backlog/backlog-eligibility.js";
-import { planDependencyAlert, skippedMergeFiles, staleMerges, staleOpenBugs, stalePrompts, staleWaitingBugs } from "../status-payload.js";
+import { operatorHeldEntries, refusedEntries, stalledEntries } from "../../backlog/backlog-eligibility.js";
+import { capacityContention, droppedPostReviewsAlert, flappedChecksAlert, mainRuleFailures, notifyFailures, planDependencyAlert, postMergeChurnAlert, postReviewRiskAlert, primaryOverwriteBlocks, qaCoverageAlert, quarantineAlert, regressedFixesAlert, skippedMergeFiles, staleMerges, staleOpenBugs, staleOpenQuestions, stalePrompts, staleWaitingBugs, staleWorkspacePins } from "../status-payload.js";
+import { strandedPlanEntriesFor } from "../../backlog/backlog-structure.js";
+import { duplicatedBacklogHeadings, fixClaimProblems, liveFinishedEntriesFor, validationGapProblems } from "../../doctor/doctor-backlog-plans.js";
 import { snapshot } from "../../status/status-data.js";
 import { renderStatusSpans } from "../status-render.js";
+import { staleClaimEntries } from "../../scheduling/claim-entries.js";
 import { teamAlerts } from "../team-alerts.js";
 import { captureStartupBuild, createReloadWatch, reexecSelf, watchReloadSupervisor, } from "../../redeploy/self-reload.js";
 import { renderInputView, tuiTerminalError, } from "./tui-input.js";
@@ -90,7 +93,7 @@ export async function runTui(root, seams = {}) {
         const view = s.view;
         // What needs the operator — the dashboard's alert banners (team-alerts.ts's teamAlerts), as
         // attention lines under the header. Each consumes one line of the height budget.
-        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), operatorHeldEntries(root), staleOpenBugs(root), stalePrompts(root), staleMerges(root), planDependencyAlert(root), staleWaitingBugs(root), skippedMergeFiles(root), stalledPlanEntries(root)), width);
+        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), operatorHeldEntries(root), staleOpenBugs(root), stalePrompts(root), staleMerges(root), planDependencyAlert(root), staleWaitingBugs(root), skippedMergeFiles(root), stalledEntries(root), quarantineAlert(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), notifyFailures(root), primaryOverwriteBlocks(root), capacityContention(root), flappedChecksAlert(root), regressedFixesAlert(root, Date.now()), postMergeChurnAlert(root), postReviewRiskAlert(root), droppedPostReviewsAlert(root), mainRuleFailures(root, Date.now()), staleClaimEntries(root, status.roles.map((r) => r.role), Date.now()), staleOpenQuestions(root), fixClaimProblems(root), qaCoverageAlert(root, Date.now()), staleWorkspacePins(root, Date.now()), liveFinishedEntriesFor(root)), width);
         const statusLines = [status.lines[0] ?? [], ...attention, ...status.lines.slice(1)];
         // Numbered previews of prompts queued for the director, between the table and the
         // activity pane: what will run next, in execution order. Each line consumes exactly
@@ -112,7 +115,7 @@ export async function runTui(root, seams = {}) {
                                 : view === roleIds.length + 6 ? { kind: "queued", grep: s.queuedGrep }
                                     : view === roleIds.length + 7 ? { kind: "health", problems: s.healthProblems }
                                         : view === roleIds.length + 8 ? { kind: "brief" }
-                                            : { kind: "activity", role: s.activityRole, grep: s.activityGrep, type: s.activityType };
+                                            : { kind: "activity", role: s.activityRole, grep: s.activityGrep, type: s.activityType, notable: s.activityNotable };
         // The pane's body lines (tui-pane.ts, extracted from this closure): transcripts, the
         // backlog views, usage/failures, or activity, composed at this frame's budgets.
         const paneResult = paneBody(pane, { root, width, eventBudget, entryBudget, state: s });
@@ -121,7 +124,7 @@ export async function runTui(root, seams = {}) {
         // The frame as the ink tree draws it (tui-app.tsx): the same composed lines the
         // hand-painted string frame joined, as clipped StatusLines — one column row per line,
         // one styled Text per span, colors through tui-app.tsx's toneColor.
-        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, quietMode: s.quietMode, quietTeam: s.quietTeam, providerCapsMode: s.providerCapsMode, claudeReserveMode: s.claudeReserveMode, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
+        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, checksMode: s.checksMode, checkMode: s.checkMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, roleEnabledMode: s.roleEnabledMode, quietMode: s.quietMode, quietTeam: s.quietTeam, providerCapsMode: s.providerCapsMode, claudeReserveMode: s.claudeReserveMode, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
         const lines = [...statusLines, []]; // a blank row below the header
         for (const [i, preview] of queued.entries())
             lines.push(toneLine(`${i + 1}. ${preview}`, width));

package/dist/src/verdict/fix-claim.js

@@ -45,7 +45,7 @@
  *   bare file name is backed by a file of that name anywhere in the walked source dirs. */
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { extname, join } from "node:path";
-import { readTextOrNull, walkFiles } from "../files/files.js";
+import { readTextOrNull, statOrNull, walkFiles } from "../files/files.js";
 import { fenceTracker, finishedArchiveOf, parseEntryDetails, sectionLines, trailingParenthetical, } from "../backlog/backlog-md.js";
 import { changeBaseRev, fileContentAt } from "../git/git.js";
 import { collapseWhitespace, truncate } from "../text/text.js";
@@ -217,6 +217,52 @@ export function sourceHaystack(root) {
     }
     return parts.join("\n");
 }
+/** The module-level cache backing cachedSourceHaystack, keyed by root. Cleared wholesale past a
+ * small cap, like the other stat caches (src/files/stat-cache.ts) — evicting only costs one
+ * re-walk and re-read per tree on the next call. */
+const sourceHaystackCache = new Map();
+const HAYSTACK_CACHE_MAX = 64;
+/** sourceHaystack with a stat-keyed cache so the always-on observer poll reads the tree only
+ * when a file changed: the first call per root walks the tree once and, on every later call,
+ * builds a signature from each file's path + mtimeMs + size (all stat-only, sorted so the walk
+ * order cannot matter) and returns the cached text unchanged when the signature matches, or
+ * re-reads on a change. Transparent — its return equals sourceHaystack(root) for the same tree —
+ * so the merge gate keeps calling sourceHaystack and never notices the cache. */
+export function cachedSourceHaystack(root) {
+    const signature = sourceHaystackSignature(root);
+    const cached = sourceHaystackCache.get(root);
+    if (cached?.signature === signature)
+        return cached.text;
+    const text = sourceHaystack(root);
+    if (sourceHaystackCache.size >= HAYSTACK_CACHE_MAX)
+        sourceHaystackCache.clear();
+    sourceHaystackCache.set(root, { signature, text });
+    return text;
+}
+/** The stat-only signature a cachedSourceHaystack call compares: every source file the haystack
+ * reads (docs excluded, exactly as sourceHaystack does) plus package.json/tsconfig.json, each as
+ * `path:mtimeMs:size`. Sorted so the walk order cannot matter; an unreadable or missing file
+ * contributes nothing, the same way sourceHaystack skips it — except a file that is stat-able
+ * but unreadable, which contributes its stat but read nothing: the cache then keys on a byte-for-
+ * byte consistent shape, never stale text. */
+function sourceHaystackSignature(root) {
+    const sigs = [];
+    const docExts = new Set([".md", ".markdown"]);
+    const add = (p) => {
+        const st = statOrNull(p);
+        if (st?.isFile())
+            sigs.push(`${p}:${st.mtimeMs}:${st.size}`);
+    };
+    walkSourceFiles(root, (p, entry) => {
+        if (docExts.has(extname(entry.name).toLowerCase()))
+            return;
+        add(p);
+    });
+    for (const file of ["package.json", "tsconfig.json"])
+        add(join(root, file));
+    sigs.sort();
+    return sigs.join("|");
+}
 /** Every file under the source dirs the haystack reads (src/, test/, scripts/), node_modules and
  * dist trees skipped at any depth. */
 function walkSourceFiles(root, visit) {

package/dist/src/verdict/reply-contract.js

@@ -185,6 +185,41 @@ export function extractFlow(text) {
         return null;
     return { flow: match[1].trim(), result: match[2].toLowerCase() };
 }
+/** Extract the `ci` run's result-carrying `CI: <sha> — <passed|failed>` line (plans, part
+ * 3/3); null when absent. Built on `labeledLine`, so the label is anchored at line start and
+ * a mid-sentence mention is ignored. The verdict is required and the sha must be a hex id: a
+ * bare `CI: <sha>` — or a reply truncated mid-verdict (`CI: abc123 — pa`) — is not a result,
+ * and returning null leaves the parity ledger unadvanced rather than latching a coverage the
+ * run never declared (the same lesson as qa's FLOW line, BUGS.md 2026-09-23). Splits on the
+ * dash/em-dash token before the verdict. */
+export function extractCiResult(text) {
+    const value = labeledLine(text, "CI");
+    if (!value)
+        return null;
+    const match = /^([0-9a-f]{7,64})\s*[—-]\s*(passed|failed)\s*$/i.exec(value);
+    if (!match?.[1])
+        return null;
+    return { sha: match[1].toLowerCase(), result: match[2].toLowerCase() };
+}
+/** The paths a post-merge review's rejecting reply pairs with its verdict to declare a repair
+ * (Forward never back 1a/6): `FIX: <comma-separated paths>` naming the files the reviewer edited
+ * in the review worktree. Unlike `labeledLine` — whose `\s` can span the newline, so
+ * a bare `FIX:` with no content of its own would borrow the next line and read as paths — this
+ * regex anchors its content to ONE line: the label is anchored at line start (a mid-sentence
+ * mention is ignored), the content is captured on the same line, and each comma-separated path is
+ * whitespace-trimmed. The paths are required — a bare `FIX:` (or a reply truncated so the line
+ * carries none) records nothing and the review stays a plain reject, the same fail-closed lesson
+ * as qa's FLOW line (BUGS.md 2026-09-23). null when no usable one-line list exists. */
+export function fixLine(text) {
+    const match = /^[ \t]*FIX:[ \t]*(.+?)[ \t]*$/m.exec(text);
+    if (!match)
+        return null;
+    const paths = match[1]
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    return paths.length > 0 ? paths : null;
+}
 /** The shortest a filed title may be to count as a declared result. A truncated `FILED:` line
  * cuts the title off mid-word (`FILED: #12 — tit` where the run meant `title`); requiring a
  * title of at least this many characters keeps a torn line from being latched as a filing the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tumwater",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Opinionated autonomous development harness built on pi. You write the initial prompt; role-driven loops build the project.",
   "type": "module",
   "license": "MIT",

package/dist/src/baseline/main-culprit.js

@@ -1,94 +0,0 @@
-import { cachedBaselineVerdict, checkMainBaseline } from "./main-baseline.js";
-import { baselineCheckLogger } from "./main-red.js";
-import { CHECK_TIER } from "../concurrency/check-permit.js";
-import { gitTry } from "../git/git-run.js";
-import { treeDiffFiles } from "../git/git-diff.js";
-import { ensureDetachedWorktree } from "../git/worktree.js";
-import { gateMainWorktreePath } from "../paths.js";
-import { isExemptDiff } from "../review/exemptions.js";
-import { onlyQuarantined } from "../review/known-flakes.js";
-import { readEvents } from "../events/event-read.js";
-import { TUMWATER_SOURCE } from "../events/events.js";
-import { shortSha } from "../text/format.js";
-/** How many first-parent commits below the red tip the search for a last green looks at. */
-const CULPRIT_SEARCH_MAX = 50;
-/** How many recent events the owner lookup reads; an older `merged` event counts as none. */
-const OWNER_EVENT_TAIL = 2000;
-/** Name the first-parent commit that turned main red at `red.sha` (plans/fast-merge.md, Lever 2,
- * part 4a). Runs inside the main watch's `_gate-main` checkout `wt`, re-pointing it per candidate
- * and back at the tip before returning. Finds the newest first-parent commit with a cached green
- * verdict, re-checks it fresh (a green that is red now means the environment broke, not a
- * change), then bisects the commits since it — skipping doc-only ones — for the first red. A
- * search that cannot name a commit says why instead of guessing. */
-export async function findRedCulprit(root, wt, config, red) {
-    const tip = red.sha;
-    const onRun = baselineCheckLogger(root, TUMWATER_SOURCE);
-    const mirror = gateMainWorktreePath(root);
-    const at = async (sha) => {
-        await ensureDetachedWorktree(root, mirror, sha);
-    };
-    const check = async (sha, reverifyRed, forceFresh, observedOnly) => {
-        await at(sha);
-        return (await checkMainBaseline(wt, config, onRun, reverifyRed, forceFresh, undefined, observedOnly, CHECK_TIER.merge))
-            .baseline;
-    };
-    try {
-        const walk = ((await gitTry(wt, "rev-list", "--first-parent", `--max-count=${CULPRIT_SEARCH_MAX + 1}`, tip)) ?? "")
-            .split("\n")
-            .filter((s) => s !== "")
-            .slice(1);
-        const green = walk.find((sha) => cachedBaselineVerdict(sha) === "green");
-        if (!green) {
-            return { kind: "unattributed", reason: `no green commit within ${CULPRIT_SEARCH_MAX} first-parent commits` };
-        }
-        const recheck = await check(green, false, true, false);
-        if (!recheck)
-            return { kind: "unattributed", reason: `the check made no verdict at ${shortSha(green)}` };
-        if (recheck.status === "red")
-            return { kind: "environment", green };
-        const exempt = config.review.exemptPaths;
-        const since = ((await gitTry(wt, "rev-list", "--first-parent", "--reverse", `${green}..${tip}`)) ?? "")
-            .split("\n")
-            .filter((s) => s !== "");
-        const candidates = [];
-        for (const sha of since) {
-            const files = await treeDiffFiles(wt, `${sha}^`, sha);
-            if (files === null || !isExemptDiff(files, exempt))
-                candidates.push(sha);
-        }
-        if (candidates.length === 0)
-            return { kind: "unattributed", reason: "no non-doc commit since the last green" };
-        // The last candidate is taken as red unrun: it is the tip, or only doc commits follow it.
-        let lo = 0;
-        let hi = candidates.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            const verdict = await check(candidates[mid], false, false, true);
-            if (!verdict)
-                return { kind: "unattributed", reason: `the check made no verdict at ${shortSha(candidates[mid])}` };
-            if (verdict.status === "red" && !onlyQuarantined(root, verdict.failingTests))
-                hi = mid;
-            else
-                lo = mid + 1;
-        }
-        const commit = candidates[lo];
-        const confirmed = await check(commit, true, false, true);
-        if (confirmed?.status !== "red" || onlyQuarantined(root, confirmed.failingTests)) {
-            return { kind: "unattributed", reason: `red did not reproduce at ${shortSha(commit)}` };
-        }
-        const failingTests = red.failingTests ?? []; // G was just verified green, so it carries none to subtract
-        const merged = readEvents(root, OWNER_EVENT_TAIL)
-            .reverse()
-            .find((ev) => ev.type === "merged" && ev.commit === commit);
-        return {
-            kind: "culprit",
-            commit,
-            ...(merged ? { runner: merged.source } : {}),
-            failingTests,
-            green,
-        };
-    }
-    finally {
-        await at(tip);
-    }
-}

package/dist/src/baseline/main-revert.js

@@ -1,133 +0,0 @@
-import { queueCulpritHeal } from "./main-red.js";
-import { gateCommandOf } from "../build/build-check-detect.js";
-import { runScopedBuildCheck } from "../build/build-check-scoped.js";
-import { withLock } from "../concurrency/lock.js";
-import { logEventBestEffort, TUMWATER_SOURCE, warnEventBestEffort } from "../events/events.js";
-import { branchHead, patchId } from "../git/git.js";
-import { gitTry } from "../git/git-run.js";
-import { stampedSubject } from "../git/commit-message.js";
-import { ensureDetachedWorktree } from "../git/worktree.js";
-import { useWorktree } from "../git/worktree-use.js";
-import { ffMainToOrWhy } from "../merge/merge-git.js";
-import { revertCommitIn } from "../operator/revert.js";
-import { mergeLockDir, mergeWorktreePath } from "../paths.js";
-import { DIRECTOR_ROLE } from "../roles/roles.js";
-import { baseRoleOf } from "../roles/runner-ids.js";
-import { errorMessage } from "../text/text.js";
-import { shortSha } from "../text/format.js";
-const REVERT_PREFIXES = ["tumwater(operator): Revert", "tumwater(tumwater): Revert"]; // vocabulary-ok: commit prefixes are machine strings
-/** Why the culprit is not reverted automatically, or null when it should be: no runner (an
- * operator or hand commit), a director's merge, a revert itself, or a commit whose revert
- * already merged. */
-export async function revertSkipReason(root, mainBranch, c) {
-    if (c.runner === undefined)
-        return "no role runner merged it";
-    if (baseRoleOf(c.runner) === DIRECTOR_ROLE)
-        return "the director merged it";
-    const subject = ((await gitTry(root, "log", "-1", "--format=%s", c.commit)) ?? "").trim();
-    if (REVERT_PREFIXES.some((p) => subject.startsWith(p)))
-        return "it is itself a revert";
-    const merged = (await gitTry(root, "log", mainBranch, "--format=%s", "--fixed-strings", `--grep=Revert ${shortSha(c.commit)}`)) ?? "";
-    if (merged.split("\n").some((s) => REVERT_PREFIXES.some((p) => s === `${p} ${shortSha(c.commit)}`)))
-        return "a revert of it already merged";
-    return null;
-}
-/** The main watch's culprit hand-off: starts the automatic revert, or falls back to bugfix's heal
- * prompt when the revert is skipped. Never rejects, because its caller discards the promise and an
- * unhandled rejection would end the orchestrator: a heal prompt that cannot be queued is warned. */
-export async function routeMainCulprit(root, mainBranch, c, startRevert) {
-    const skip = await revertSkipReason(root, mainBranch, c);
-    if (skip === null) {
-        startRevert(c);
-        return;
-    }
-    try {
-        queueCulpritHeal(root, c.tip, { culprit: c.commit, failingTests: c.failingTests });
-    }
-    catch (err) {
-        warnEventBestEffort(root, TUMWATER_SOURCE, `not reverting ${shortSha(c.commit)} (${skip}) and could not queue the heal prompt for bugfix: ${errorMessage(err)}`);
-    }
-}
-/** Run one revert task on main's current tip in the shared `_merge` checkout: revert the culprit,
- * run `check.gateCommand` on the result when one is set (red aborts), and fast-forward main under
- * the merge lock. Logs `main_revert` on success and calls `onReverted` (the hand-back to a role);
- * every failure queues the heal prompt instead. Never throws: a hand-off that cannot be queued is
- * warned, not thrown. */
-export async function runMainRevert(root, mainBranch, config, c, onReverted, onFailed) {
-    /** Hand the failure to a role and return the warning's suffix saying truthfully what happened. */
-    const heal = (reason, outputTail) => {
-        const toReviewer = c.postReview && onFailed;
-        try {
-            if (toReviewer)
-                onFailed(c, reason);
-            else
-                queueCulpritHeal(root, c.tip, { culprit: c.commit, failingTests: c.failingTests, outputTail });
-            return toReviewer ? "sent the reviewer's reasons to its role" : "queued the heal prompt for bugfix";
-        }
-        catch (err) {
-            return toReviewer
-                ? `could not send the reviewer's reasons to its role: ${errorMessage(err)}`
-                : `could not queue the heal prompt for bugfix: ${errorMessage(err)}`;
-        }
-    };
-    try {
-        const failure = await useWorktree(root, mergeWorktreePath(root), async () => {
-            const tip = await branchHead(root, mainBranch);
-            if (tip === null)
-                return { reason: `${mainBranch} is unreadable` };
-            const wt = await ensureDetachedWorktree(root, mergeWorktreePath(root), tip);
-            const subject = ((await gitTry(wt, "log", "-1", "--format=%s", c.commit)) ?? "").trim();
-            const tests = c.failingTests.length > 0 ? `\n\nFailing tests: ${c.failingTests.join("; ")}` : "";
-            const why = c.postReview
-                ? `which a post-merge review rejected.\n\nReasons: ${c.postReview.reasons.join("; ")}`
-                : `which turned main red.${tests}`;
-            const message = `${stampedSubject("tumwater", `Revert ${shortSha(c.commit)}`)}\n\nReverts ${c.commit} (${subject}), ${why}`;
-            const reverted = await revertCommitIn(wt, c.commit, message);
-            if (!reverted.ok)
-                return { reason: reverted.error };
-            if (gateCommandOf(config) !== undefined) {
-                const gate = await runScopedBuildCheck(root, TUMWATER_SOURCE, "gate", wt, config);
-                if (gate && gate.outcome.status !== "passed")
-                    return { reason: `the gate command was ${gate.outcome.status} on the revert`, tail: gate.outcome.outputTail };
-            }
-            const ffFailure = await withLock(mergeLockDir(root), () => ffMainToOrWhy(root, reverted.sha, mainBranch));
-            if (ffFailure !== null)
-                return { reason: ffFailure };
-            // The culprit's patch-id (`C^...C`, src/git/git.ts patchId, -U0 so a re-landing onto a
-            // moved main keeps the id): the fast-merge guardrail G2 matches a later `merged`
-            // event against it to spot a change that came back unchanged (plans/fast-merge.md).
-            const culpritPatch = await patchId(wt, `${c.commit}^`, c.commit).catch(() => null);
-            logEventBestEffort(root, {
-                source: TUMWATER_SOURCE,
-                type: "main_revert",
-                commit: c.commit,
-                revert: reverted.sha,
-                runner: c.runner,
-                failingTests: c.failingTests,
-                ...(culpritPatch ? { patchId: culpritPatch } : {}),
-            });
-            await onReverted?.(c).catch((err) => logEventBestEffort(root, {
-                source: TUMWATER_SOURCE,
-                type: "warning",
-                message: `could not hand ${shortSha(c.commit)} back to its role: ${errorMessage(err)}`,
-            }));
-            return null;
-        });
-        if (failure !== null) {
-            const suffix = heal(failure.reason, failure.tail);
-            logEventBestEffort(root, {
-                source: TUMWATER_SOURCE,
-                type: "warning",
-                message: `could not revert ${shortSha(c.commit)}: ${failure.reason} — ${suffix}`,
-            });
-        }
-    }
-    catch (err) {
-        const suffix = heal(errorMessage(err));
-        logEventBestEffort(root, {
-            source: TUMWATER_SOURCE,
-            type: "warning",
-            message: `revert of ${shortSha(c.commit)} failed: ${errorMessage(err)} — ${suffix}`,
-        });
-    }
-}