tumwater 0.4.2 → 0.4.4

package/dist/src/history/history.js

@@ -3,7 +3,7 @@ import { betweenWindow, durationLabel, failRivalShapes, failUntilShorterThanSinc
 import { HISTORY_DEFAULT_RUNS, HISTORY_MAX_RUNS, HISTORY_RESULT_FLAG_NAMES, HISTORY_SUMMARY_GROUPS, historyClass, parseHistoryResultClass, readRunRows, readRunRowsSince, runRows, summarizeRunRows, summarizeRunRowsByModel, runRowsMatchingGrep, runRowsOnModels } from "./history-data.js";
 import { renderModelSummary, renderRow, renderSummary, widenWidths, widestWidths } from "./history-render.js";
 import { LOGS_SINCE_MAX_MS, SPARSE_WINDOW_NOTE } from "../events/event-window.js";
-import { followUntilParentGone } from "../cli/log-commands.js";
+import { followUntilParentGone } from "../cli/cli-log-commands.js";
 import { hasFollowFlag } from "../cli/cli-flag-specs.js";
 import { parseEventLine, readEventsTailWithEnd } from "../events/event-read.js";
 import { eventsLogPath } from "../paths.js";
@@ -23,7 +23,7 @@ export function parseHistoryModelList(raw) {
     return pieces;
 }
 /** `tumwater history [--role <id>[,<id>...]] [-n N]`: one row per completed run, newest first. The
- * observing half beside cmdLogs (log-commands.ts): read-only over the event log, stdout only —
+ * observing half beside cmdLogs (cli-log-commands.ts): read-only over the event log, stdout only —
  * every datum rides the `run_end` events src/run/run-finalize.ts already writes, so this
  * is a rendering of the existing record, not a new one. The rows themselves are collected
  * by history-data.ts (beside src/report/report-data.ts and src/failure/failure-data.ts), and
@@ -31,7 +31,7 @@ export function parseHistoryModelList(raw) {
  * src/report/report-render.ts); this module parses the args, drives the CLI, and prints. */
 /** The missing-pattern error cmdHistory prints for a valueless or empty `--grep`, exported so
  * cli.ts's rejectUnknownArgs spec for --grep can fail a trailing `history --grep` with the same
- * wording. Kept local to this module — log-commands.ts holds its own GREP_VALUE_ERROR — so the
+ * wording. Kept local to this module — cli-log-commands.ts holds its own GREP_VALUE_ERROR — so the
  * two observing views' wordings each name the command that printed them. */
 export const HISTORY_GREP_VALUE_ERROR = "history --grep needs a pattern";
 /** The missing-value error cmdHistory prints for a valueless or empty `--result`, exported so
@@ -166,11 +166,9 @@ function applyHistoryModelFilter(rows, rest) {
     }
     return { rows, models };
 }
-/** Render the collected-and-filtered rows: the `--by`/`--summary` summary grouping, the `--json`
- * document, the empty-state wording (blaming the filter that emptied the set, else the log or
- * window), the aligned table, and the sparse-window note. A bad `--by` value fails here, after
- * row collection and filtering and before `--json`. */
-function sayHistory(rows, q, covered, filtered) {
+/** Validate `--by`'s value and its `--summary` requirement; return whether the grouping is by
+ * model (false for `role`). One home for "can this `--by` proceed, and does it group by model?" */
+function historySummaryGroup(q) {
     // `--by role|model` picks how --summary groups its lines (role by default).
     const byRaw = flagValue(q.rest, "--by");
     let byModel = false;
@@ -184,6 +182,52 @@ function sayHistory(rows, q, covered, filtered) {
             fail("history --by needs --summary (it picks how the summary groups runs)");
         byModel = byRaw === "model";
     }
+    return byModel;
+}
+/** The empty-set prose: blame the filter that emptied the set (model, then result, then grep),
+ * else the log or window. Never the `no runs yet`/`no runs in <window>` prose when rows were
+ * scanned and filtered out — the runs are there, none match. */
+function sayHistoryEmpty(q, filtered) {
+    // A grep that matched nothing must not borrow the empty-log prose: `no runs yet` and
+    // `no runs in 2h` are statements about the LOG and the WINDOW, and both are false when
+    // rows were scanned and filtered out — the operator would read a quiet team where the
+    // truth is `the runs are there, none match`. The logs --grep rule (its `no events
+    // matching "<pattern>"`, src/cli/cli-log-commands.ts) names the pattern instead; --json stays
+    // a bare {"rows":[]} document above, never prose in either form.
+    //
+    // The result class is named only when it emptied a non-empty set (`afterGrep > 0`): an
+    // empty log or window scanned no rows, so the result filter removed nothing and the
+    // empty-log/window prose is the true one — the dashboard's History view draws the same
+    // line. A grep that admitted nothing keeps its own wording regardless of --result.
+    say(filtered.models !== null && filtered.afterResult > 0
+        ? `no runs on model "${filtered.models.join(",")}"`
+        : filtered.classes !== null && filtered.afterGrep > 0
+            ? `no runs with result "${filtered.classes.join(",")}"`
+            : q.grepPattern !== null
+                ? `no runs matching "${q.grepPattern}"`
+                : q.sinceMs === null
+                    ? "no runs yet"
+                    : q.untilMs === null
+                        ? `no runs in ${durationLabel(q.sinceMs)}`
+                        : `no runs ${betweenWindow(q.sinceMs, q.untilMs)}`);
+}
+/** Render the non-empty rows: the summary (model or role) when `--summary`, else the aligned
+ * table. Called only with `rows.length > 0`.
+ */
+function sayHistoryRows(rows, summary, byModel) {
+    if (summary)
+        say(byModel ? renderModelSummary(summarizeRunRowsByModel(rows)) : renderSummary(summarizeRunRows(rows)));
+    else {
+        const widths = widestWidths(rows);
+        say(rows.map((r) => renderRow(r, widths)).join("\n"));
+    }
+}
+/** Render the collected-and-filtered rows: the `--by`/`--summary` summary grouping, the `--json`
+ * document, the empty-state wording (blaming the filter that emptied the set, else the log or
+ * window), the aligned table, and the sparse-window note. A bad `--by` value fails here, after
+ * row collection and filtering and before `--json`. */
+function sayHistory(rows, q, covered, filtered) {
+    const byModel = historySummaryGroup(q);
     const summary = q.rest.includes("--summary") && rows.length > 0;
     // --json swaps the renderer for the collector's own payload, exactly as status --json and
     // report --json: the same rows the table prints, each with ts/tokens/costUsd kept raw. A
@@ -194,36 +238,10 @@ function sayHistory(rows, q, covered, filtered) {
         return;
     }
     if (rows.length === 0) {
-        // A grep that matched nothing must not borrow the empty-log prose: `no runs yet` and
-        // `no runs in 2h` are statements about the LOG and the WINDOW, and both are false when
-        // rows were scanned and filtered out — the operator would read a quiet team where the
-        // truth is `the runs are there, none match`. The logs --grep rule (its `no events
-        // matching "<pattern>"`, src/cli/log-commands.ts) names the pattern instead; --json stays
-        // a bare {"rows":[]} document above, never prose in either form.
-        //
-        // The result class is named only when it emptied a non-empty set (`afterGrep > 0`): an
-        // empty log or window scanned no rows, so the result filter removed nothing and the
-        // empty-log/window prose is the true one — the dashboard's History view draws the same
-        // line. A grep that admitted nothing keeps its own wording regardless of --result.
-        say(filtered.models !== null && filtered.afterResult > 0
-            ? `no runs on model "${filtered.models.join(",")}"`
-            : filtered.classes !== null && filtered.afterGrep > 0
-                ? `no runs with result "${filtered.classes.join(",")}"`
-                : q.grepPattern !== null
-                    ? `no runs matching "${q.grepPattern}"`
-                    : q.sinceMs === null
-                        ? "no runs yet"
-                        : q.untilMs === null
-                            ? `no runs in ${durationLabel(q.sinceMs)}`
-                            : `no runs ${betweenWindow(q.sinceMs, q.untilMs)}`);
+        sayHistoryEmpty(q, filtered);
         return;
     }
-    if (summary)
-        say(byModel ? renderModelSummary(summarizeRunRowsByModel(rows)) : renderSummary(summarizeRunRows(rows)));
-    else {
-        const widths = widestWidths(rows);
-        say(rows.map((r) => renderRow(r, widths)).join("\n"));
-    }
+    sayHistoryRows(rows, summary, byModel);
     // A sparse window is never mistaken for a quiet team — but the note only ever rides rows
     // (an empty window returned above), it never touches --json output, and it is the shared
     // SPARSE_WINDOW_NOTE wording: the oldest retained event being inside the window is exactly

package/dist/src/inbox/prompt-commands.js

@@ -179,10 +179,10 @@ function runPromptImageGate(root, target) {
     if (guidance.notice)
         say(guidance.notice);
 }
-/** `--edit <n>` mode — replace a queued prompt's body by position: the attachment gate, then
- * the editor for a bare position or the typed/`--file` text, list-wide or `--role`-scoped. One
- * helper so `--edit`'s rules are found by name. */
-function runPromptEdit(root, position, text, attachPaths, role) {
+/** The `--edit` attachment phase: read the `--attach` image list (undefined when there is
+ * none) and run the image-input gate under the role the edit targets — the position's
+ * resolved role when no `--role` narrows it. */
+function readEditAttachments(root, position, attachPaths, role) {
     // The same broken-config policy and list-wide resolution as cancel, one verb over: the
     // file's new content rides the same queue file (position, enqueue stamp, and a pending
     // --at deferral untouched), and a concurrent dequeue reports gone and exits clean. An
@@ -200,48 +200,66 @@ function runPromptEdit(root, position, text, attachPaths, role) {
         const targetRole = role ?? resolveListedRole(root, position);
         runPromptImageGate(root, targetRole);
     }
-    const typed = text;
-    if (typed === null) {
-        // Bare `--edit <n>`: open the prompt's body in the editor. The role is resolved first
-        // and the write goes by file name, so a dequeue while the editor is open reports gone
-        // instead of editing the neighbour that shifted into the position.
-        const targetRole = role ?? resolveListedRole(root, position);
-        let name;
-        let body;
-        try {
-            name = path.basename(queuedFileAtPosition(root, targetRole, position));
-            body = readQueuedPromptBody(root, targetRole, name);
-        }
-        catch (err) {
-            return fail(errorMessage(err));
-        }
-        if (body === null) {
-            sayPromptOutcome(position, targetRole, { status: "gone" }, role === null);
-            return;
-        }
-        const after = editInEditor(body, "prompt.md");
-        // An emptied buffer is an abort, not a blank prompt: the queue would otherwise hold a
-        // prompt with no text, which the enqueue forms refuse.
-        if (after.trim() === "" && body.trim() !== "")
-            fail("the edited prompt is empty; nothing changed (use --cancel <n> to drop it)");
-        if (after.trim() === body.trim() && images === undefined) {
-            say(`prompt ${position} unchanged`);
-            return;
-        }
-        try {
-            sayPromptOutcome(position, targetRole, editQueuedFile(root, targetRole, name, after, images), role === null);
-        }
-        catch (err) {
-            fail(errorMessage(err));
-        }
+    return images;
+}
+/** The bare `--edit <n>` arm: resolve the role, read the queued body by file name (so a
+ * concurrent dequeue reports gone), open it in the editor and write the result back —
+ * unchanged, emptied or edited — with the carried `images`. */
+function editBareQueuedPrompt(root, position, role, images) {
+    // Bare `--edit <n>`: open the prompt's body in the editor. The role is resolved first
+    // and the write goes by file name, so a dequeue while the editor is open reports gone
+    // instead of editing the neighbour that shifted into the position.
+    const targetRole = role ?? resolveListedRole(root, position);
+    let name;
+    let body;
+    try {
+        name = path.basename(queuedFileAtPosition(root, targetRole, position));
+        body = readQueuedPromptBody(root, targetRole, name);
+    }
+    catch (err) {
+        return fail(errorMessage(err));
+    }
+    if (body === null) {
+        sayPromptOutcome(position, targetRole, { status: "gone" }, role === null);
         return;
     }
+    const after = editInEditor(body, "prompt.md");
+    // An emptied buffer is an abort, not a blank prompt: the queue would otherwise hold a
+    // prompt with no text, which the enqueue forms refuse.
+    if (after.trim() === "" && body.trim() !== "")
+        fail("the edited prompt is empty; nothing changed (use --cancel <n> to drop it)");
+    if (after.trim() === body.trim() && images === undefined) {
+        say(`prompt ${position} unchanged`);
+        return;
+    }
+    try {
+        sayPromptOutcome(position, targetRole, editQueuedFile(root, targetRole, name, after, images), role === null);
+    }
+    catch (err) {
+        fail(errorMessage(err));
+    }
+}
+/** The typed `--edit <n> <text>` / `--file` arm: the list-wide `editListedPrompt` path when
+ * no `--role`, else the role-scoped `editRolePrompt` command, with the carried `images`. */
+function editTypedQueuedPrompt(root, position, text, role, images) {
     if (role === null) {
-        sayListedOutcome(editListedPrompt(root, listWideScope(root), position, typed, images), position);
+        sayListedOutcome(editListedPrompt(root, listWideScope(root), position, text, images), position);
         return;
     }
     const target = role ?? DIRECTOR_ROLE;
-    sayPromptOutcome(position, target, runRolePromptCommand(root, target, position, (r, role, position) => editRolePrompt(r, role, position, typed, images)), false);
+    sayPromptOutcome(position, target, runRolePromptCommand(root, target, position, (r, role, position) => editRolePrompt(r, role, position, text, images)), false);
+}
+/** `--edit <n>` mode — replace a queued prompt's body by position: read the `--attach` image
+ * list through the gate, then the editor for a bare position or the typed/`--file` text,
+ * list-wide or `--role`-scoped. The three phases live in `readEditAttachments`,
+ * `editBareQueuedPrompt` and `editTypedQueuedPrompt`, so each `--edit` job is found by name. */
+function runPromptEdit(root, position, text, attachPaths, role) {
+    const images = readEditAttachments(root, position, attachPaths, role);
+    if (text === null) {
+        editBareQueuedPrompt(root, position, role, images);
+        return;
+    }
+    editTypedQueuedPrompt(root, position, text, role, images);
 }
 /** `--top <n>` mode — move a queued prompt to the head of its queue by position, list-wide or
  * `--role`-scoped. One helper so `--top`'s rules are found by name. */
@@ -283,8 +301,7 @@ function runPromptSubmit(root, text, atDelayMs, attachPaths, role) {
     // `--attach <path>`: read and validate through the shared helper (a bad path fails by name
     // before anything is queued). An attachment the target role cannot read is refused here by
     // name — the same gate submitRolePrompt enforces, surfaced early so the CLI exits non-zero
-    // with the fix before anything is written or queued; a role that reroutes a blind read is
-    // not refused, but the operator is told where the prompt will actually run.
+    // with the fix before anything is written or queued.
     const images = attachPaths.length > 0 ? readPromptImages(attachPaths) : undefined;
     if (images && images.length > 0) {
         runPromptImageGate(root, target);

package/dist/src/init/init.js

@@ -234,26 +234,8 @@ async function resolveInitPlan(root, briefText, branch, opts) {
     const preferredBranch = await resolveInitPreferredBranch(root, branch, wasRepo);
     return { dryRun, tpl, combinedPrompt, brief, readmeExists, adopted, wasRepo, preferredBranch };
 }
-/** Seed `root` from a resolved `InitPlan`: git init (a new repo only), every absent project
- * file and starter directory, the config, and the commit. Holds the `created`/`leftAlone`
- * bookkeeping locally; performs no validation and never refuses. Returns everything the
- * composed `InitResult` needs except `adopted`, `dryRun` and `template`, which `initProject`
- * reads off `plan`. */
-async function seedProject(root, plan) {
-    const { dryRun, tpl, combinedPrompt, brief, readmeExists, adopted, wasRepo, preferredBranch } = plan;
-    let repoInitialized = false;
-    let createdBranch;
-    if (!wasRepo) {
-        if (!dryRun)
-            await git(root, "init", "-b", preferredBranch);
-        repoInitialized = true;
-        createdBranch = preferredBranch;
-    }
-    // Decided before any project file is written (init only seeds bootstrap on a fresh project).
-    // A repo the `git init` above just created (or a dry run would) has no commits, and init
-    // itself commits nothing before the end, so this one answer also picks the commit message.
-    const withCommits = wasRepo && (await hasCommits(root));
-    const fresh = await isFreshProject(root, withCommits);
+/** The `created`/`leftAlone` arrays and the `claim`/`write` closures above them. */
+function seedWriters(root, dryRun) {
     const created = [];
     const leftAlone = [];
     /** Record a template path this run either created (via `make`, under a real run only) or
@@ -275,33 +257,64 @@ async function seedProject(root, plan) {
     // because claim's existsSync would then treat the torn file as complete on a re-run and
     // never repair it.
     const write = (name, content) => claim(name, path.join(root, name), () => writeTextAtomic(path.join(root, name), content));
+    return { created, leftAlone, claim, write };
+}
+/** The new-repo `git init` job: seed the preferred branch unless the run is a dry run. */
+async function initSeedRepo(root, plan) {
+    let repoInitialized = false;
+    let createdBranch;
+    if (!plan.wasRepo) {
+        if (!plan.dryRun)
+            await git(root, "init", "-b", plan.preferredBranch);
+        repoInitialized = true;
+        createdBranch = plan.preferredBranch;
+    }
+    return { repoInitialized, createdBranch };
+}
+/** Whether `root` is a fresh project and the repo has commits — decided before any project
+ * file is written (init only seeds bootstrap on a fresh project). A repo the `git init`
+ * above just created (or a dry run would) has no commits, and init itself commits nothing
+ * before the end, so this one answer also picks the commit message. */
+async function resolveSeedFreshness(root, plan) {
+    const withCommits = plan.wasRepo && (await hasCommits(root));
+    const fresh = await isFreshProject(root, withCommits);
+    return { withCommits, fresh };
+}
+/** Where the brief goes: the existing brief file, TUMWATER.md (adopted), or README.md. */
+function seedBriefFile(root, plan, writers) {
     // README.md is the brief only when none exists yet and there is no README to adopt (a fresh
     // repo): with TUMWATER.md owning the managed sections, a created README.md would carry a
     // duplicate prompt + status block that readBriefText never reaches and the readme role
     // never maintains.
     const name = projectName(root);
-    if (brief !== null)
-        leftAlone.push(brief);
-    else if (adopted) {
-        if (readmeExists)
-            leftAlone.push("README.md");
-        write("TUMWATER.md", briefTemplate(name, combinedPrompt));
+    if (plan.brief !== null)
+        writers.leftAlone.push(plan.brief);
+    else if (plan.adopted) {
+        if (plan.readmeExists)
+            writers.leftAlone.push("README.md");
+        writers.write("TUMWATER.md", briefTemplate(name, plan.combinedPrompt));
     }
     else
-        write("README.md", readmeTemplate(name, combinedPrompt));
+        writers.write("README.md", readmeTemplate(name, plan.combinedPrompt));
+}
+/** The template backlog files: PLANS/BUGS/QUESTIONS/PRINCIPLES, with starter-plans subst. */
+function seedBacklogFiles(tpl, writers) {
     // A template with starter plans seeds the backlog with them, rendered as `### ` entries —
     // the primary entry format every backlog reader parses — so the team's first runs land on
     // real work. blank keeps the `_None yet._` placeholder byte-identical to today.
     const plansContent = tpl.starterPlans.length > 0
         ? PLANS_TEMPLATE.replace("_None yet._", tpl.starterPlans.map((p) => `### ${p}`).join("\n\n"))
         : PLANS_TEMPLATE;
-    write("PLANS.md", plansContent);
-    write("BUGS.md", BUGS_TEMPLATE);
-    write("QUESTIONS.md", QUESTIONS_TEMPLATE);
-    write("PRINCIPLES.md", PRINCIPLES_TEMPLATE);
+    writers.write("PLANS.md", plansContent);
+    writers.write("BUGS.md", BUGS_TEMPLATE);
+    writers.write("QUESTIONS.md", QUESTIONS_TEMPLATE);
+    writers.write("PRINCIPLES.md", PRINCIPLES_TEMPLATE);
+}
+/** The config seed and its fresh-project bootstrap; returns the seeded bootstrap count. */
+function seedConfigFile(root, fresh, dryRun, writers) {
     let bootstrap = null;
     if (fs.existsSync(configPath(root)))
-        leftAlone.push(CONFIG_BASENAME);
+        writers.leftAlone.push(CONFIG_BASENAME);
     else {
         const seed = seedConfig(root);
         if (fresh) {
@@ -310,26 +323,36 @@ async function seedProject(root, plan) {
         }
         if (!dryRun)
             saveConfig(root, seed);
-        created.push(CONFIG_BASENAME);
+        writers.created.push(CONFIG_BASENAME);
     }
+    return bootstrap;
+}
+/** The .gitignore edit: gain the missing lines, or record it as left alone. */
+function seedGitignore(root, dryRun, writers) {
     if (ensureGitignore(root, dryRun))
-        created.push(".gitignore");
+        writers.created.push(".gitignore");
     else if (fs.existsSync(path.join(root, ".gitignore")))
-        leftAlone.push(".gitignore");
+        writers.leftAlone.push(".gitignore");
+}
+/** The template's starter directories — empty ones only, before the first run. */
+function seedStarterDirs(root, tpl, writers) {
     // The template's starter directories: empty ones only, before the first run — the team's
     // own runs write any code. Existing directories are left alone, like existing files above.
     for (const dir of tpl.starterDirs) {
-        claim(dir, path.join(root, dir), () => ensureDir(path.join(root, dir)));
+        writers.claim(dir, path.join(root, dir), () => ensureDir(path.join(root, dir)));
     }
+}
+/** What gets committed: the committable filter and the `git add` / staged-check / commit. */
+async function commitSeeded(root, plan, withCommits, writers) {
     // The config stays out of the commit pathspec: `git add -- tumwater.json` fails on a path
     // the just-written .gitignore ignores (plans/portability.md §4a/7). It still heads the
     // `created …` line the CLI prints — the file WAS created, it just must not be tracked. When
     // that leaves the pathspec empty (`git add --` with no pathspec exits 1), there is nothing
     // to commit: a repo that only gained a config reports it and stays uncommitted.
-    const dirSet = new Set(tpl.starterDirs);
-    const committable = created.filter((name) => name !== CONFIG_BASENAME && !dirSet.has(name));
+    const dirSet = new Set(plan.tpl.starterDirs);
+    const committable = writers.created.filter((name) => name !== CONFIG_BASENAME && !dirSet.has(name));
     let committed = false;
-    if (!dryRun && committable.length > 0) {
+    if (!plan.dryRun && committable.length > 0) {
         await git(root, "add", "--", ...committable);
         const staged = await gitTry(root, "diff", "--cached", "--quiet");
         if (staged === null) {
@@ -339,7 +362,32 @@ async function seedProject(root, plan) {
             committed = true;
         }
     }
-    return { created, leftAlone, committed, repoInitialized, branch: createdBranch, bootstrap };
+    return committed;
+}
+/** Seed `root` from a resolved `InitPlan`: git init (a new repo only), every absent project
+ * file and starter directory, the config, and the commit. Holds the `created`/`leftAlone`
+ * bookkeeping locally; performs no validation and never refuses. Returns everything the
+ * composed `InitResult` needs except `adopted`, `dryRun` and `template`, which `initProject`
+ * reads off `plan`. */
+async function seedProject(root, plan) {
+    const { dryRun, tpl } = plan;
+    const { repoInitialized, createdBranch } = await initSeedRepo(root, plan);
+    const { withCommits, fresh } = await resolveSeedFreshness(root, plan);
+    const writers = seedWriters(root, dryRun);
+    seedBriefFile(root, plan, writers);
+    seedBacklogFiles(tpl, writers);
+    const bootstrap = seedConfigFile(root, fresh, dryRun, writers);
+    seedGitignore(root, dryRun, writers);
+    seedStarterDirs(root, tpl, writers);
+    const committed = await commitSeeded(root, plan, withCommits, writers);
+    return {
+        created: writers.created,
+        leftAlone: writers.leftAlone,
+        committed,
+        repoInitialized,
+        branch: createdBranch,
+        bootstrap,
+    };
 }
 /** Initialize a repo for tumwater: README (with prompt + status) when no project brief exists
  * yet, PLANS, BUGS, QUESTIONS, PRINCIPLES, tumwater.json, .gitignore — then commit whatever was

package/dist/src/merge/merge-backlog-conflicts.js

@@ -314,7 +314,7 @@ export async function resolveBacklogInsertConflicts(wt, files) {
         }
         // Atomic (tmp + rename): a merge process killed mid-write (SIGKILL, the timeout
         // group-kill) must leave either the conflicted file or the fully resolved one, never a
-        // truncated backlog — the CLI's backlog writers (backlog-write.ts, question-answer.ts)
+        // truncated backlog — the CLI's backlog writers (backlog-write.ts, backlog-question-answer.ts)
         // already write these unbounded-history files through this helper.
         writeTextAtomic(p, resolved);
         await git(wt, "add", "--", file);

package/dist/src/merge/merge-check-failures.js

@@ -3,7 +3,7 @@ import { mergeRefName } from "../paths.js";
 import { recordReview } from "../run/run-apply.js";
 import { saveRunnerStateBestEffort } from "../runner/runner-state.js";
 import { unverifiedTreeOutcome } from "../build/build-check-events.js";
-import { checkFailureReasons, describeCheck, failureHeadline } from "../build/build-check-report.js";
+import { checkFailureReasons, redCheckHeadline } from "../build/build-check-report.js";
 import { onlyKnownMainFailures } from "../baseline/main-watch.js";
 import { mainTipVerdict } from "../baseline/main-red.js";
 import { logEventBestEffort, warnEventBestEffort } from "../events/events.js";
@@ -126,7 +126,7 @@ export async function mergeCheckRed(ctx, role, wt, red) {
     if (result === "merge_blocked" && !attributed) {
         warnEventBestEffort(ctx.root, role, `merge check failed (kept for one retry): ${reason}`);
         if (ctx.state.mergeCheckFailures) {
-            ctx.state.mergeCheckFailures.headline = failureHeadline(red.outcome.outputTail) ?? describeCheck(red.check);
+            ctx.state.mergeCheckFailures.headline = redCheckHeadline(red.check, red.outcome.outputTail);
         }
     }
     return result;
@@ -143,15 +143,18 @@ export function noteMergeRetryPassed(ctx, role, pinPatch) {
     if (headline)
         warnEventBestEffort(ctx.root, role, MERGE_FLAKY_WARNING_PREFIX + headline);
 }
-/** A merge blocked by a deterministic cross-check (onMergeBlocked's fix-claim or
- * backlog-structure reason — a property of the tree ahead of main, not a flaky run). The
- * block is counted like a red merge check, keyed by the same patch-id: under
- * MERGE_CHECK_FAILURE_LIMIT the pin is kept for one recovery re-merge — main may have moved
- * under the rebase, and a differently-rebased tree can pass the cross-check — but at the
+/** A merge blocked by a deterministic cross-check — a property of the tree ahead of main,
+ * not a flaky run. The block is counted like a red merge check, keyed by the same patch-id:
+ * under MERGE_CHECK_FAILURE_LIMIT the pin is kept for one recovery re-merge — main may have
+ * moved under the rebase, and a differently-rebased tree can pass the cross-check — but at the
  * limit the block is attributed to the change: rejected deterministically with the block
  * reason, the pin deleted, no model run. Without this a resolution that trips the same
  * cross-check on every re-resolve pays a fresh conflict-resolver run each run, forever
- * (BUGS.md 2026-10-02: five resolver sessions for one fix-claim-blocked pin). */
+ * (BUGS.md 2026-10-02: five resolver sessions for one fix-claim-blocked pin). Since part 3m/3
+ * the merge path no longer produces cross-check blocks (a fix claim and a broken backlog
+ * structure are repairable and land for the main watch), so nothing in the in-lock path calls
+ * this today; it stays as the strike-counting sink, still pinned by INV-BF2 and retired with
+ * the queue by 3f/3. */
 export async function mergeBlocked(ctx, role, wt, blocked) {
     return keepPinOrAttribute(ctx, wt, blocked, (head) => rejectChange(ctx, role, head, [`merge blocked: ${blocked}`], ctx.state));
 }
@@ -185,7 +188,7 @@ export async function attributeRedCheck(ctx, role, head, label, red, state) {
     const kept = keepForKnownFailures(ctx, role, label, red, state);
     if (kept)
         return kept;
-    const headline = failureHeadline(red.outcome.outputTail) ?? describeCheck(red.check);
+    const headline = redCheckHeadline(red.check, red.outcome.outputTail);
     const key = normalizeClusterKey(headline);
     if (isKnownFlake(ctx.root, headline) && state.mergeFlakeExcused !== key) {
         state.mergeFlakeExcused = key;

package/dist/src/merge/merge-core.js

@@ -6,12 +6,11 @@ import { ensureDetachedWorktree } from "../git/worktree.js";
 import { useWorktree } from "../git/worktree-use.js";
 import { mergeToMain } from "./merge-to-main.js";
 import { rebaseOntoMain } from "./merge-git.js";
-import { mergeCheckRed, mergeBlocked, noteMergeRetryPassed } from "./merge-check-failures.js";
+import { mergeCheckRed, noteMergeRetryPassed } from "./merge-check-failures.js";
 import { reviewAheadOfMain } from "../review/review.js";
-import { reviewRunConfig, modelSelectorField } from "../config/config-views.js";
-import { warnEventBestEffort, logEventBestEffort } from "../events/events.js";
+import { logEventBestEffort } from "../events/events.js";
 import { saveRunnerStateBestEffort } from "../runner/runner-state.js";
-import { REVISION_FINAL_ON_REPEAT, REVISION_BACKSTOP, holdEntryAfterExhaustion } from "../runner/revision.js";
+import { REVISION_FINAL_ON_REPEAT, REVISION_BACKSTOP, holdEntryAfterExhaustion } from "../runner/runner-revision.js";
 import { priorObjectionNumber } from "../review/review-verdict.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
 import { shortSha } from "../text/format.js";
@@ -89,16 +88,14 @@ function reviewContextFor(ctx, req, wt, foldUsage) {
  * merge (a restart hand-off past its deadline, BUGS.md 2026-09-23) would otherwise sail
  * through its gate into the check. */
 export async function reviewPinnedChange(ctx, req, wt, state, foldUsage) {
-    const { root, config } = ctx;
+    const { root } = ctx;
     const { role } = req;
     const ref = mergeRefName(role);
     // Both uses below — a rejection and a strike-cap discard — end a pinned change without
-    // keeping it: drop the held-selector note and the pin ref together, so the two-part cleanup
-    // cannot drift between them. The verify's checkout is a pooled slot (plans/worktree-pool.md,
+    // keeping it: drop the pin ref. The verify's checkout is a pooled slot (plans/worktree-pool.md,
     // "Vets and merges"): verifyRequest releases the lease in its finally, and a slot is reused, so
     // this path must not remove the worktree it ran in.
     const discardPin = async () => {
-        state.mergeReviewError = undefined;
         await deleteRef(root, ref);
     };
     // Already stopping: the gate never starts, so nothing is persisted or folded — the ref stays
@@ -163,19 +160,6 @@ export async function reviewPinnedChange(ctx, req, wt, state, foldUsage) {
     }
     if (gate.decision === "failed") {
         state.lastError = `review failed: ${gate.detail}`;
-        // A permanent provider configuration error can never succeed until the config changes, so
-        // record the held pin with the reviewer selector that failed: leftover recovery refuses to
-        // re-queue while that selector stands and clears the hold once it changes (BUGS.md
-        // 2026-10-06). A discarded pin is gone, so no hold is recorded for it.
-        if (gate.configError && !gate.discarded) {
-            const selector = modelSelectorField(reviewRunConfig(config)).model;
-            state.mergeReviewError = {
-                sha: req.sha,
-                ...(selector ? { selector } : {}),
-                message: state.lastError,
-            };
-            warnEventBestEffort(root, role, `review blocked by a permanent provider configuration error${selector ? ` on ${selector}` : ""}: ${gate.detail} — the pinned change is held until the model config changes`);
-        }
         // Strike-cap discard: the gate says so directly (it reset the worktree off the pin) — the
         // commit is gone and the ref goes too. An under-cap failure — a dead reviewer — keeps the
         // pin as it is: the gate never commits, so the pin still names the tree the next re-merge
@@ -195,8 +179,6 @@ export async function reviewPinnedChange(ctx, req, wt, state, foldUsage) {
         await setRef(root, ref, sha);
         req = { ...req, sha };
     }
-    // The change may merge: nothing is held against the previous reviewer selector any more.
-    state.mergeReviewError = undefined;
     return { kind: "gate", gate, sha };
 }
 /** The failed merge outcomes that KEEP the pin for another attempt: an under-cap review
@@ -291,7 +273,6 @@ async function mergeApprovedChangeIn(ctx, req) {
     const wt = await ensureDetachedWorktree(ctx.root, mergeWorktreePath(ctx.root), req.sha);
     const pinPatch = await patchId(wt, ctx.mainBranch, req.sha).catch(() => null);
     let red;
-    let blocked;
     const result = await mergeToMain({
         root: ctx.root,
         role: req.role,
@@ -303,9 +284,6 @@ async function mergeApprovedChangeIn(ctx, req) {
         onMergeCheckRed: (check, outcome) => {
             red = { check, outcome };
         },
-        onMergeBlocked: (reason) => {
-            blocked = reason;
-        },
         recheckResolved: async (resolvedWt) => {
             if (ctx.signal().aborted)
                 return { verdict: "retry" };
@@ -357,12 +335,9 @@ async function mergeApprovedChangeIn(ctx, req) {
     }
     if (result === "merge_blocked" && red)
         return mergeCheckRed(ctx, req.role, wt, red);
-    if (result === "merge_blocked" && blocked !== undefined) {
-        return mergeBlocked(ctx, req.role, wt, blocked);
-    }
     // merge_conflict / merge_blocked: keep the ref — the next run's recovery re-merges it.
-    // (Cross-check blocks no longer come through here: merge-check-failures.ts's mergeBlocked
-    // counts them.)
+    // (The deterministic cross-check blocks — fix-claim and backlog structure — no longer come
+    // through here: since part 3m/3 they are repairable and land for the main watch.)
     // A rejected recheck already wrote its own lastError and deleted its ref — leave it.
     if (result !== "rejected")
         ctx.state.lastError = `merge failed: ${result}`;