tumwater 0.1.2 → 0.2.0

package/dist/src/backlog/backlog-render.js

@@ -1,19 +1,47 @@
-import { holdMark } from "./backlog-eligibility.js";
+import { groupBlockedSeries, partsLabel } from "./backlog-structure.js";
+import { holdMark, inProgressMark } from "./backlog-eligibility.js";
 /** One `## ` section: its entries verbatim, or the single `_(none)_` placeholder line. When
  * `holds` is given, entry `i`'s hold mark rides on its `### ` heading. */
-function renderSection(title, entries, holds) {
+function renderSection(title, entries, holds, inProgress) {
     const lines = [`## ${title}`, ""];
     if (entries.length === 0) {
         lines.push("_(none)_", "");
         return lines;
     }
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        lines.push(`### ${entry.title}${holdMark(holds?.[i] ?? null)}`, "");
-        // The body is already trimmed by parseEntryDetails; only the indent is added here.
-        for (const line of entry.body.split("\n"))
-            lines.push(line === "" ? "" : `  ${line}`);
-        lines.push("");
+    for (let i = 0; i < entries.length; i++)
+        lines.push(...renderEntry(entries[i], holds?.[i] ?? null, inProgress?.[i] ?? null));
+    return lines;
+}
+/** One entry: its heading with hold and in-progress marks, then its body indented two spaces. */
+function renderEntry(entry, hold, runner) {
+    const lines = [`### ${entry.title}${holdMark(hold)}${inProgressMark(runner)}`, ""];
+    // The body is already trimmed by parseEntryDetails; only the indent is added here.
+    for (const line of entry.body.split("\n"))
+        lines.push(line === "" ? "" : `  ${line}`);
+    lines.push("");
+    return lines;
+}
+/** The Planned section. With holds, each series with two or more blocked parts prints as one
+ * body-less heading at its first part's place (the grouping `plan --list` uses); every other
+ * entry prints as renderSection would. Without holds it is renderSection itself. */
+function renderPlannedSection(entries, holds, inProgress) {
+    if (!holds || entries.length === 0)
+        return renderSection("Planned features", entries, holds, inProgress);
+    const rows = entries.map((entry, index) => ({
+        index, title: entry.title, hold: holds[index] ?? null, claimer: inProgress?.[index] ?? undefined,
+    }));
+    const lines = ["## Planned features", ""];
+    let grouped = false;
+    for (const g of groupBlockedSeries(rows)) {
+        if (g.kind === "row") {
+            lines.push(...renderEntry(entries[g.row.index], g.row.hold, inProgress?.[g.row.index] ?? null));
+            continue;
+        }
+        grouped = true;
+        lines.push(`### ${g.series}, ${g.rows.length} blocked parts (${partsLabel(g.rows)}) [blocked: each waits on an earlier part]`, "");
+    }
+    if (grouped) {
+        lines.push("_(each blocked series is one heading; `tumwater plan --show <n>` prints a part, `tumwater backlog --json` lists every entry)_", "");
     }
     return lines;
 }
@@ -21,8 +49,31 @@ function renderSection(title, entries, holds) {
  * Markdown. */
 export function renderBacklogMarkdown(payload) {
     const lines = ["# tumwater backlog", ""];
-    lines.push(...renderSection("Planned features", payload.plans, payload.holds?.plans));
-    lines.push(...renderSection("Open bugs", payload.bugs, payload.holds?.bugs));
+    lines.push(...renderPlannedSection(payload.plans, payload.holds?.plans, payload.inProgress?.plans));
+    lines.push(...renderSection("Open bugs", payload.bugs, payload.holds?.bugs, payload.inProgress?.bugs));
     lines.push(...renderSection("Open questions", payload.questions));
     return lines.join("\n").trimEnd();
 }
+/** The view with only the plans and bugs no hold keeps from being picked: entry `i` stays when
+ * `holds.plans[i]` / `holds.bugs[i]` is null, and `holds` and `inProgress` are filtered by the
+ * same indexes so the arrays stay parallel. An entry a role is working on has no hold, so it
+ * stays with its in-progress mark. Questions carry no holds and pass through; a view without
+ * `holds` is returned unchanged. */
+export function readyBacklog(view) {
+    const holds = view.holds;
+    if (!holds)
+        return view;
+    const keep = (hs, n) => Array.from({ length: n }, (_, i) => i).filter((i) => (hs[i] ?? null) === null);
+    const plan = keep(holds.plans, view.plans.length);
+    const bug = keep(holds.bugs, view.bugs.length);
+    const pick = (xs, idx) => idx.map((i) => xs?.[i]);
+    return {
+        ...view,
+        plans: pick(view.plans, plan),
+        bugs: pick(view.bugs, bug),
+        holds: { plans: pick(holds.plans, plan), bugs: pick(holds.bugs, bug) },
+        ...(view.inProgress
+            ? { inProgress: { plans: pick(view.inProgress.plans, plan), bugs: pick(view.inProgress.bugs, bug) } }
+            : {}),
+    };
+}

package/dist/src/backlog/backlog-structure.js

@@ -1,15 +1,20 @@
+// vocabulary: plain
 import path from "node:path";
 import { increment } from "../collections.js";
 import { readTextOrNull } from "../files/files.js";
 import { cachedTextByStat } from "../files/stat-cache.js";
-import { BACKLOG_FILES, fenceTracker, headingMetadata, parseEntryDetails, sectionBodyLines, fenceAwareHeadingLines, headingTitle, } from "./backlog-md.js";
+import { BACKLOG_FILES, FINISHED_ARCHIVES, fenceTracker, headingMetadata, parseEntryDetails, sectionBodyLines, fenceAwareHeadingLines, headingTitle, } from "./backlog-md.js";
 import { changeBaseRev, fileContentAt } from "../git/git.js";
+import { allLiveClaims } from "../loop/loop-state.js";
 import { collapseWhitespace, truncate } from "../text/text.js";
-import { entryHoldAgainst, holdMark, plannedPartKeys } from "./backlog-eligibility.js";
+import { entryHoldAgainst, holdMark, plannedPartKeys, seriesPart, } from "./backlog-eligibility.js";
 import { plannedPlanEntries } from "./backlog.js";
+/** The archive files of PLANS.md and BUGS.md (FINISHED_ARCHIVES). */
+const PLANS_ARCHIVE = FINISHED_ARCHIVES[0].archive;
+const BUGS_ARCHIVE = FINISHED_ARCHIVES[1].archive;
 /** The stamp verbs a backlog heading's trailing `(planned 2026-09-29)`-style parenthetical
  * opens with — the same list the backlog writers stamp and the dashboards parse. One home
- * for the verb list: the TUI's fleet alerts strip the suffix (stripEntryStamp) and the
+ * for the verb list: the TUI's team alerts strip the suffix (stripEntryStamp) and the
  * dashboard's browser view model splits it off as metadata (splitTitle), and a new stamp
  * verb must reach both renders.
  * Kept as pattern SOURCE rather than a RegExp so the browser twin (a String.raw template
@@ -20,16 +25,44 @@ export const ENTRY_STAMP_META_SOURCE = String.raw `\s*\(((?:planned|reported|fou
 const ENTRY_STAMP_META_RE = new RegExp(ENTRY_STAMP_META_SOURCE, "i");
 /** A heading or title with its trailing `(planned 2026-09-29)`-style stamp suffix removed,
  * whitespace otherwise untouched — the shared span of this module's indexTitle, eligibility's
- * entryKey and seriesPart, and the TUI fleet alerts, which all read a heading stamp-free. */
+ * entryKey and seriesPart, and the TUI team alerts, which all read a heading stamp-free. */
 export function stripEntryStamp(title) {
     return title.replace(ENTRY_STAMP_META_RE, "");
 }
+/** The heading of a `## Done`/`## Fixed` entry with its completion stamp removed. Cuts at the
+ * first `dateRe` match, drops a parenthetical the cut left open (`(found by … 2026-10-01; `,
+ * `(planned …; `), ignores a stray `)` (`… now under ## Fixed); fixed 2026-10-04 …)`), trims
+ * trailing separators, then strips a closed `(planned …)`/`(found …)` stamp suffix. `dateRe`
+ * matches nothing in the result. */
+export function finishedTitle(title, dateRe) {
+    const match = dateRe.exec(title);
+    let t = match ? title.slice(0, match.index) : title;
+    const open = [];
+    for (let i = 0; i < t.length; i++) {
+        if (t[i] === "(")
+            open.push(i);
+        else if (t[i] === ")" && open.length)
+            open.pop();
+    }
+    if (open.length)
+        t = t.slice(0, open[0]);
+    t = t.replace(/[\s,;:—–-]+$/, "");
+    return stripEntryStamp(t).trimEnd();
+}
 /** A heading's parenthetical dates: `(planned YYYY-MM-DD` opens a plan entry; `done
  * YYYY-MM-DD` records its completion. Matched against the JOINED heading metadata
  * (headingMetadata), never the bare first line — many headings wrap their dates onto a
  * second line (`(planned 2026-09-02, done` / `2026-09-03)`). */
 const PLANNED_DATE = /\(planned \d{4}-\d{2}-\d{2}/;
 const DONE_DATE = /\bdone \d{4}-\d{2}-\d{2}/;
+/** A completion stamp: `done YYYY-MM-DD` introduced by a structural delimiter (`— done`,
+ * `, done`, `; done`, `(done`) rather than by an English subject in prose. Every entry-own done
+ * record in PLANS.md is delimiter-introduced (`…planned …, done …`, `…planned …; done …`,
+ * `…) — done …`, `…) (done …)`); a "done DATE" that merely names PRIOR merged work is a
+ * participle ("…part 2/2 … both done 2026-10-16, …") whose `done` follows a word, so this
+ * narrower regex does not match it and a mention inside a heading's own `(planned …)` prose
+ * cannot strand the entry. */
+const DONE_STAMP = /[—,(;]\s*done \d{4}-\d{2}-\d{2}/;
 /** The `### ` headings of `md`'s PLANS.md that sit under the wrong section, in file order:
  * (a) entries under `## Done` whose heading carries a `(planned YYYY-MM-DD…)` parenthetical
  * but no `done YYYY-MM-DD` — written as plans, never stamped done, and invisible to every
@@ -58,7 +91,16 @@ export function strandedPlanEntries(md) {
             if (!line.startsWith("### "))
                 continue;
             const { text } = headingMetadata(lines, i);
-            if (section === "Done" ? PLANNED_DATE.test(text) && !DONE_DATE.test(text) : DONE_DATE.test(text))
+            // A `## Done` entry is stranded when it carries the `(planned …)` opener but no done
+            // stamp of its own. An entry still under `## Planned` is stranded only when its heading
+            // carries a completion stamp — a `done YYYY-MM-DD` introduced by a structural delimiter
+            // (`— done`, `, done`, `; done`, `(done`), the repo's completion shapes. A "done DATE" that
+            // merely describes PRIOR merged work ("…both done 2026-10-16, …") follows an English word,
+            // not a delimiter, so DONE_STAMP does not match it and the entry is not stranded.
+            const misplaced = section === "Done"
+                ? PLANNED_DATE.test(text) && !DONE_DATE.test(text)
+                : DONE_STAMP.test(text);
+            if (misplaced)
                 stranded.push({ title: headingTitle(line, "### "), section });
         }
     }
@@ -97,8 +139,8 @@ function sectionTitleCounts(md) {
     return counts;
 }
 /** The `## ` titles of `md` that appear more than once, in first-appearance order — the
- * duplicate-heading signal `checkBacklogHeadings` reports for main and
- * `backlogStructureReason` checks on a tree being landed. */
+ * duplicate-heading signal `checkBacklogHeadings` reports for main and `backlogStructureReason`
+ * checks on a tree being merged. */
 export function duplicateHeadings(md) {
     return [...sectionTitleCounts(md)].filter(([, n]) => n > 1).map(([title]) => title);
 }
@@ -129,30 +171,29 @@ export function doubleBlockFixedEntries(md) {
     }
     return found;
 }
-/** The first structural fault a diff landing on `mainBranch` leaves in a backlog file, or
- * undefined when none: for each touched backlog file it compares the `## ` heading set of the
- * tree being landed (`wt`) against the diff's merge-base — the same base falseFixReason
- * measures against, so a stacked batch is judged change by change — and rejects when
- * (a) the head carries MORE of a title than the base carried (a duplicate `## Done` added, or
- * a second one where the base had none), or (b) a title present on the base is gone from the
- * head (a whole section dropped). The rule is deliberately about heading sets, not section
- * names: a project whose BUGS.md adds `## Verified` (this repo's does) or a fresh repo seeded
- * from src/init/init.ts's templates passes unchanged. A base that already carries a duplicate never
- * blocks unrelated edits — rule (a) fires only when the head's count EXCEEDS the base's, so a
- * change that removes a duplicate always passes. For PLANS.md there is a third rule
- * (part 4/4): a head that ADDS a `### ` entry directly under `## Done` whose joined heading
- * metadata carries `(planned YYYY-MM-DD` but no `done YYYY-MM-DD`, and whose key the base's
- * PLANS.md never carried in ANY section, is a plan filed into the wrong section — rejected with
- * a reason naming the entry and the one-line fix. Judged against the merge-base (the same base
- * the heading rules use), so a Planned → Done move of an entry the base already had passes, a
- * stacked batch is measured change by change, and a pre-existing stranded entry (whose key the
- * base has) never blocks unrelated landings — the clean loop's repair (part 3/4) owns those.
- * BUGS.md has one more: a head `## Fixed` entry that holds more than one `**Symptom:**` or
- * `**Fix:**` block (doubleBlockFixedEntries) absorbed a headingless record into its body; a
- * base body that already had the shape is never re-flagged, so only a newly merged record is
- * rejected (BUGS.md 2026-10-08). Detection is deterministic markdown reading —
- * no pi — so both the review gate (exempt and code diffs alike) and the in-lock landing
- * re-check can afford it on every landing (plans: "Backlog structure check", part 2/4). */
+/** The first structural fault a diff merging into `mainBranch` leaves in a backlog file, or
+ * undefined when none: for each touched backlog file it compares the `## ` heading set of the tree
+ * being merged (`wt`) against the diff's merge-base — the same base falseFixReason measures
+ * against, so a stacked batch is judged change by change — and rejects when (a) the head carries
+ * MORE of a title than the base carried (a duplicate `## Done` added, or a second one where the
+ * base had none), or (b) a title present on the base is gone from the head (a whole section
+ * dropped). The rule is deliberately about heading sets, not section names: a project whose BUGS.md
+ * adds `## Verified` (this repo's does) or a fresh repo seeded from src/init/init.ts's templates
+ * passes unchanged. A base that already carries a duplicate never blocks unrelated edits — rule (a)
+ * fires only when the head's count EXCEEDS the base's, so a change that removes a duplicate always
+ * passes. For PLANS.md there is a third rule (part 4/4): a head that ADDS a `### ` entry directly
+ * under `## Done` whose joined heading metadata carries `(planned YYYY-MM-DD` but no `done
+ * YYYY-MM-DD`, and whose key the base's PLANS.md never carried in ANY section, is a plan filed into
+ * the wrong section — rejected with a reason naming the entry and the one-line fix. Judged against
+ * the merge-base (the same base the heading rules use), so a Planned → Done move of an entry the
+ * base already had passes, a stacked batch is measured change by change, and a pre-existing
+ * stranded entry (whose key the base has) never blocks unrelated merges — the clean loop's repair
+ * (part 3/4) owns those. BUGS.md has one more: a head `## Fixed` entry that holds more than one
+ * `**Symptom:**` or `**Fix:**` block (doubleBlockFixedEntries) absorbed a headingless record into
+ * its body; a base body that already had the shape is never re-flagged, so only a newly merged
+ * record is rejected (BUGS.md 2026-10-08). Detection is deterministic markdown reading — no pi — so
+ * both the review gate (exempt and code diffs alike) and the in-lock merge re-check can afford it
+ * on every merge (plans: "Backlog structure check", part 2/4). */
 export async function backlogStructureReason(wt, mainBranch, files) {
     const touched = files.filter((f) => BACKLOG_FILES.has(f));
     if (touched.length === 0)
@@ -172,45 +213,52 @@ export async function backlogStructureReason(wt, mainBranch, files) {
             if (!headCounts.has(title))
                 return (`${file} drops the "## ${title}" section the base had — entries filed under it would ` +
                     `be invisible to every section reader; restore "## ${title}"`);
-        // Part 4/4's rule, PLANS.md only (see this function's doc comment): a NEW plan filed
-        // directly under ## Done with no done date. strandedPlanEntries already does the
-        // fence-aware, joined-metadata reading the first two conditions need; the base's key set
-        // supplies the third.
-        if (file === "PLANS.md") {
-            const baseKeys = planHeadingKeys(base);
+        // Part 4/4's rule, PLANS.md and its archive (see this function's doc comment): a NEW plan
+        // filed directly under ## Done with no done date. strandedPlanEntries already does the
+        // fence-aware, joined-metadata reading the first two conditions need; the base's key set —
+        // over both files, since tumwater moves a finished plan from one to the other
+        // (plans/backlog-archive.md) — supplies the third.
+        if (file === "PLANS.md" || file === PLANS_ARCHIVE) {
+            const baseKeys = new Set([
+                ...planHeadingKeys(file === "PLANS.md" ? base : await fileContentAt(wt, baseRev, "PLANS.md")),
+                ...planHeadingKeys(file === PLANS_ARCHIVE ? base : await fileContentAt(wt, baseRev, PLANS_ARCHIVE)),
+            ]);
             const newcomer = strandedPlanEntries(head).find((e) => e.section === "Done" && !baseKeys.has(planHeadingKey(e.title)));
             if (newcomer)
-                return (`PLANS.md files "${newcomer.title}" directly under "## Done" with no done date — a plan ` +
+                return (`${file} files "${newcomer.title}" directly under "## Done" with no done date — a plan ` +
                     `written into the done section is invisible to every Planned reader; file it under ` +
-                    `"## Planned" instead`);
+                    `"## Planned"${file === "PLANS.md" ? "" : " in PLANS.md"} instead`);
         }
         // A new headingless record cannot hide in a Fixed entry's body: reject a head whose
         // multi-block entries the base did not carry (an existing one never blocks unrelated
         // edits, matching the heading-set rules above). The Fix paragraph is the guard's unit, so
         // a merged second block would otherwise sit inside the neighbor it was symbol-checked
-        // against.
-        if (file === "BUGS.md") {
+        // against. BUGS-FIXED.md holds the same entries once archived.
+        if (file === "BUGS.md" || file === BUGS_ARCHIVE) {
             const baseTitles = new Set(doubleBlockFixedEntries(base));
             const newcomer = doubleBlockFixedEntries(head).find((title) => !baseTitles.has(title));
             if (newcomer)
-                return (`BUGS.md's Fixed entry "${newcomer}" holds more than one **Symptom:**/**Fix:** block — ` +
+                return (`${file}'s Fixed entry "${newcomer}" holds more than one **Symptom:**/**Fix:** block — ` +
                     `a record with no "### " heading has merged into it, so the hidden record is invisible ` +
                     `to every section reader; give it its own "### " heading`);
         }
     }
     return undefined;
 }
-/** Per-file cache of PLANS.md's stranded entries (strandedPlanEntriesFor). */
+/** Per-file cache of PLANS.md's and PLANS-DONE.md's stranded entries (strandedPlanEntriesFor). */
 const strandedPlanCache = new Map();
-/** `strandedPlanEntries` for the primary checkout's PLANS.md, stat-cached per file path
- * (stat-cache.cachedTextByStat): the clean loop asks for it every tick and `tumwater role`
- * previews the same block, and PLANS.md's `## Done` history grows without bound, so an
+/** `strandedPlanEntries` for the primary checkout's PLANS.md and PLANS-DONE.md (where finished
+ * plans are archived, plans/backlog-archive.md), each entry tagged with its file, stat-cached per
+ * file path (stat-cache.cachedTextByStat): the clean loop asks for it every tick, `tumwater role`
+ * previews the same block and doctor reports it, and the archive grows without bound, so an
  * unchanged file costs one stat instead of a full read and section walk. A missing or
  * unreadable file reads as no entries. The result is copied out, so each caller owns its
  * data. */
-function strandedPlanEntriesFor(root) {
-    const full = path.join(root, "PLANS.md");
-    return (cachedTextByStat(strandedPlanCache, full, full, (md) => strandedPlanEntries(md), (entries) => entries.slice()) ?? []);
+export function strandedPlanEntriesFor(root) {
+    return ["PLANS.md", PLANS_ARCHIVE].flatMap((file) => {
+        const full = path.join(root, file);
+        return (cachedTextByStat(strandedPlanCache, full, full, (md) => strandedPlanEntries(md).map((e) => ({ ...e, file })), (entries) => entries.slice()) ?? []);
+    });
 }
 /** The clean loop's `<backlog-structure>` prompt block for the primary checkout at `root`
  * (the same root the telemetry digest and qa coverage blocks read): a rendered block listing
@@ -223,12 +271,12 @@ export function renderBacklogStructureBlock(root) {
     if (stranded.length === 0)
         return undefined;
     const listed = stranded
-        .map((e) => `- (now under ## ${e.section}) ${e.title}`)
+        .map((e) => `- (now under ${e.file !== undefined && e.file !== "PLANS.md" ? `${e.file} ` : ""}## ${e.section}) ${e.title}`)
         .join("\n");
     // The task wording lives in the clean role's find text (src/roles/role-catalog.ts); the block
     // only carries the evidence, like the digest and coverage blocks do.
-    return `Plan headings filed under the wrong section of PLANS.md — invisible to the readers
-that scan one section, so no loop sees them as backlog work:
+    return `Plan headings filed under the wrong section of PLANS.md or PLANS-DONE.md — invisible to
+the readers that scan one section, so no role sees them as backlog work:
 <backlog-structure>
 ${listed}
 </backlog-structure>`;
@@ -301,8 +349,128 @@ const INDEX_SECTIONS = [
     { file: "BUGS.md", section: "Open" },
     { file: "QUESTIONS.md", section: "Open" },
 ];
+/** How many closed entries per closed section the index lists. */
+const RECENT_CLOSED_MAX = 5;
+/** The closed sections whose newest entries the index also lists, each read from the live file
+ * and then its archive (FINISHED_ARCHIVES, plans/backlog-archive.md); every one keeps its entries
+ * newest first, so the first entries in file order are the recent ones. */
+const CLOSED_SECTIONS = FINISHED_ARCHIVES.map((a) => ({
+    files: [a.file, a.archive],
+    section: a.section,
+}));
 /** Per-file cache of the parsed actionable entries (indexSectionCache). */
 const indexSectionCache = new Map();
+/** Per-file cache of the newest closed entries' ranges; separate from indexSectionCache, which is
+ * keyed by the file path alone and PLANS.md would collide. */
+const closedSectionCache = new Map();
+/** One `IndexRow` as an ordinary index line: range, truncated stamp-free title, hold mark, and
+ * the in-flight suffix when a live claim names it. The collapsed-series line is built by
+ * collapseBlockedSeries, returned alongside these. */
+function renderIndexRow(row) {
+    return `- ${row.start}-${row.end}: ${indexTitle(row.title)}${row.mark}${row.claimer ? ` [in flight by ${row.claimer}]` : ""}`;
+}
+/** True when `row` is a candidate for series-collapsing: it is a series part held only by an
+ * unmerged prerequisite (`{ blockedBy }`, not a Refused/needs-review/needs-replan note) and no live
+ * claim names it. Returns the row's series part when it collapses, else null. */
+function collapsibleSeriesPart(row) {
+    if (row.claimer !== undefined)
+        return null;
+    if (typeof row.hold !== "object" || row.hold === null)
+        return null;
+    return seriesPart(row.title);
+}
+/** The collapsed part list for a series' blocked parts: each part as `i/n`, with a run of
+ * consecutive numeric parts (same total, adjacent values) joined into one en-dash range
+ * (`2/5–5/5`) and each lettered part (`2a`) listed singly. */
+export function partsLabel(rows) {
+    const refs = rows.map((r) => seriesPart(r.title));
+    const pieces = [];
+    let start = null;
+    let prev = null;
+    const numeric = (p) => /^\d+$/.test(p);
+    const flush = () => {
+        if (start === null || prev === null)
+            return;
+        pieces.push(start.part === prev.part
+            ? `${start.part}/${start.of}`
+            : `${start.part}/${start.of}–${prev.part}/${prev.of}`);
+        start = null;
+        prev = null;
+    };
+    for (const ref of refs) {
+        if (prev !== null &&
+            numeric(ref.part) &&
+            numeric(prev.part) &&
+            Number(ref.part) === Number(prev.part) + 1 &&
+            ref.of === prev.of) {
+            prev = ref;
+            continue;
+        }
+        flush();
+        start = ref;
+        prev = ref;
+    }
+    flush();
+    return pieces.join(", ");
+}
+/** Renders `rows` to index lines, collapsing a multi-part series' blocked parts to one line per
+ * series (this plan, "Compact backlog index, part 1/1"): a long series' chain of held parts would
+ * otherwise fill every loop prompt with lines no role can act on. An entry collapses when it is a
+ * series part held only by an unmerged prerequisite and no live claim names it; a series with two
+ * or more such parts renders as one line at the position of its first collapsed part, spanning from
+ * that part's start to the last's end, with the part list (`2/4–4/4`) and a `[blocked: each waits
+ * on an earlier part]` mark. A series with a single blocked part, an eligible part, a note-held
+ * (Refused/needs-review/needs-replan) part and a claimed part keep their ordinary lines, so the
+ * eligibility rules the feature role's charter teaches are unchanged; the collapsed mark keeps the
+ * `[blocked: …]` prefix it already skips. */
+/** The grouping half of collapseBlockedSeries, on any rows carrying a title, hold and claimer:
+ * each series with two or more collapsible blocked parts becomes one `series` group at its first
+ * part's place; every other row stays a `row` group in order. */
+export function groupBlockedSeries(rows) {
+    // Group the collapsible rows by series, keyed on the lowercased series name.
+    const bySeries = new Map();
+    for (const row of rows) {
+        const part = collapsibleSeriesPart(row);
+        if (part === null)
+            continue;
+        const key = part.series.toLowerCase();
+        const list = bySeries.get(key) ?? [];
+        list.push(row);
+        bySeries.set(key, list);
+    }
+    // Only a series with two or more blocked parts collapses; a lone blocked part keeps its
+    // exact `requires` line.
+    const collapse = new Set();
+    for (const [key, list] of bySeries)
+        if (list.length >= 2)
+            collapse.add(key);
+    const groups = [];
+    const skipped = new Set();
+    for (const row of rows) {
+        if (skipped.has(row))
+            continue;
+        const part = collapsibleSeriesPart(row);
+        if (part !== null && collapse.has(part.series.toLowerCase())) {
+            const group = bySeries.get(part.series.toLowerCase());
+            groups.push({ kind: "series", series: part.series, rows: group });
+            for (const g of group)
+                skipped.add(g);
+            continue;
+        }
+        groups.push({ kind: "row", row });
+    }
+    return groups;
+}
+function collapseBlockedSeries(rows) {
+    return groupBlockedSeries(rows).map((g) => {
+        if (g.kind === "row")
+            return renderIndexRow(g.row);
+        const first = g.rows[0];
+        const last = g.rows[g.rows.length - 1];
+        return (`- ${first.start}-${last.end}: ${indexTitle(g.series)}, ${g.rows.length} blocked parts ` +
+            `(${partsLabel(g.rows)}) [blocked: each waits on an earlier part]`);
+    });
+}
 /** The `<backlog-index>` prompt block: each actionable entry (PLANS.md ## Planned, BUGS.md
  * ## Open, QUESTIONS.md ## Open) with its 1-based line range, rendered from the primary
  * checkout `root`. Replaces the per-tick `grep -n '^##'` heading map, whose pattern also matched
@@ -319,6 +487,12 @@ export function renderBacklogIndexBlock(root) {
     // PLANS.md costs one stat per call.
     const planned = plannedPlanEntries(root);
     const plannedParts = plannedPartKeys(planned);
+    // The cross-role in-flight hold (BUGS.md 2026-10-09): every role's prompts share this one
+    // section-agnostic index, and the role it is assembled for is not available here, so an entry
+    // claimed by ANY role is marked in flight — the owner's own index marks it too, which is harmless
+    // (its assignment note is the instruction), and every other role reads it as taken instead of
+    // re-implementing a change someone's merge is already carrying to main.
+    const claimed = allLiveClaims(root);
     const listed = [];
     for (const { file, section } of INDEX_SECTIONS) {
         const full = path.join(root, file);
@@ -339,16 +513,45 @@ export function renderBacklogIndexBlock(root) {
         if (entries === null || entries.length === 0)
             continue;
         listed.push(`${file} ## ${section}`);
-        for (const e of entries) {
-            const mark = holdMark(entryHoldAgainst({ title: e.title, body: e.body }, plannedParts));
-            listed.push(`- ${e.start}-${e.end}: ${indexTitle(e.title)}${mark}`);
+        // Build the rows once per section, then collapse a PLANS.md series' blocked parts (this
+        // plan) — BUGS.md and QUESTIONS.md sections keep every entry on its own line.
+        const rows = entries.map((e) => {
+            const hold = entryHoldAgainst({ title: e.title, body: e.body }, plannedParts);
+            const key = collapseWhitespace(stripEntryStamp(e.title)).toLowerCase();
+            return {
+                start: e.start,
+                end: e.end,
+                title: e.title,
+                hold,
+                mark: holdMark(hold),
+                claimer: claimed.get(key),
+            };
+        });
+        const isPlans = file === "PLANS.md" && section === "Planned";
+        listed.push(...(isPlans ? collapseBlockedSeries(rows) : rows.map(renderIndexRow)));
+    }
+    for (const { files, section } of CLOSED_SECTIONS) {
+        // The newest RECENT_CLOSED_MAX across the live section (normally empty) and the archive.
+        let room = RECENT_CLOSED_MAX;
+        for (const file of files) {
+            if (room <= 0)
+                break;
+            const full = path.join(root, file);
+            const entries = cachedTextByStat(closedSectionCache, full, full, (md) => actionableEntryRanges(md, section).slice(0, RECENT_CLOSED_MAX), (v) => v.slice())?.slice(0, room);
+            if (entries === undefined || entries.length === 0)
+                continue;
+            room -= entries.length;
+            listed.push(`${file} ## ${section} (newest ${entries.length})`);
+            for (const e of entries)
+                listed.push(`- ${e.start}-${e.end}: ${indexTitle(e.title)}`);
         }
     }
     if (listed.length === 0)
         return undefined;
-    return `Actionable backlog — each entry with the 1-based line range it occupies in its file.
-Read the entries you need by those ranges; the files' closed sections make a full heading map
-grow with every tick.
+    return `Backlog index — each actionable entry, then the newest closed ones, with the 1-based line range it occupies in its file.
+Read the entries you need by those ranges; the archive files (PLANS-DONE.md, BUGS-FIXED.md) grow
+with every merge, so search them rather than reading them. Blocked parts of a multi-part series are
+shown as one line per series.
 <backlog-index>
 ${listed.join("\n")}
 </backlog-index>`;