dotmd-cli 0.61.0 → 0.63.0

package/src/query.mjs

@@ -7,6 +7,7 @@ import { getGitLastModifiedBatch } from './git.mjs';
 import { extractFrontmatter } from './frontmatter.mjs';
 import { summarizeDocBody } from './ai.mjs';
 import { bold, dim, yellow, red, green, blue, magenta, cyan, brightYellow } from './color.mjs';
+import { buildRunlistIndex, buildCoordinationIndex, hubLabel } from './runlist.mjs';
 
 const STATUS_COLORS = {
   'in-session': (s) => bold(red(s)),
@@ -92,7 +93,10 @@ export function runQuery(index, argv, config, opts = {}) {
   }
 
   if (opts.preset === 'plans' || opts.preset === 'prompts') {
-    renderPlansOutput(docs, filters, config, { noun: opts.preset });
+    // Runlist folding only applies to plans (prompts have no runlists).
+    const runlist = opts.preset === 'plans' ? buildRunlistIndex(index, config) : null;
+    const coordination = opts.preset === 'plans' ? buildCoordinationIndex(index, config) : null;
+    renderPlansOutput(docs, filters, config, { noun: opts.preset, runlist, coordination });
     if (docs.length === 0) writeUnknownFilterValueHint(filters, index);
     return;
   }
@@ -101,6 +105,84 @@ export function runQuery(index, argv, config, opts = {}) {
   if (docs.length === 0) writeUnknownFilterValueHint(filters, index);
 }
 
+// Sort comparator for the runlists dashboard. Default `age` puts the MOST STALE
+// hub first — a triage lens (which nav-map has gone longest untouched?), echoing
+// `dotmd modules --sort cleanup`. `recent` is the old newest-first order.
+// Unknown-age hubs sort last in both directions so they never dominate.
+const RUNLIST_SORTS = new Set(['age', 'recent', 'related', 'title', 'status']);
+function runlistSorter(sort, coordination, config) {
+  const cmpAge = (a, b, dir) => {
+    const av = a.daysSinceUpdate, bv = b.daysSinceUpdate;
+    if (av == null && bv == null) return 0;
+    if (av == null) return 1;
+    if (bv == null) return -1;
+    return dir * (av - bv);
+  };
+  const related = (d) => coordination.get(d.path)?.childCount ?? 0;
+  const byLabel = (a, b) => hubLabel(a).localeCompare(hubLabel(b));
+  if (sort === 'recent') return (a, b) => cmpAge(a, b, 1) || byLabel(a, b);
+  if (sort === 'related') return (a, b) => related(b) - related(a) || cmpAge(a, b, -1) || byLabel(a, b);
+  if (sort === 'title') return byLabel;
+  if (sort === 'status') {
+    return (a, b) => {
+      const ai = config.statusOrder.indexOf(a.status), bi = config.statusOrder.indexOf(b.status);
+      const aIdx = ai === -1 ? Number.MAX_SAFE_INTEGER : ai, bIdx = bi === -1 ? Number.MAX_SAFE_INTEGER : bi;
+      return aIdx - bIdx || cmpAge(a, b, -1) || byLabel(a, b);
+    };
+  }
+  return (a, b) => cmpAge(a, b, -1) || byLabel(a, b); // 'age' (default): most stale first
+}
+
+// `dotmd runlists` — the dedicated coordination-hub dashboard: the `Runlists`
+// section from `dotmd plans`, on its own, showing every hub (no leaf list, no
+// cap by default — runlists are a small bounded set). `--limit N` caps it,
+// `--sort age|recent|related|title|status` orders it (default `age`, most stale
+// first), `--json` emits structured rows.
+export function runRunlists(index, argv, config) {
+  const json = argv.includes('--json');
+  let limit = Infinity;
+  const li = argv.indexOf('--limit');
+  if (li >= 0 && argv[li + 1]) { const n = Number.parseInt(argv[li + 1], 10); if (Number.isFinite(n)) limit = n; }
+  const si = argv.indexOf('--sort');
+  const sortArg = si >= 0 && argv[si + 1] ? argv[si + 1] : 'age';
+  if (!RUNLIST_SORTS.has(sortArg)) die(`Unknown --sort '${sortArg}'. Use one of: ${[...RUNLIST_SORTS].join(', ')}.`);
+
+  const coordination = buildCoordinationIndex(index, config);
+  const archived = new Set([
+    ...(config.lifecycle?.archiveStatuses ?? []),
+    ...(config.lifecycle?.terminalStatuses ?? []),
+  ]);
+  const hubs = index.docs
+    .filter(d => coordination.has(d.path) && !archived.has(d.status) && !isArchivedPath(d.path, config))
+    .sort(runlistSorter(sortArg, coordination, config));
+
+  if (json) {
+    const runlists = hubs.map(d => ({
+      path: d.path,
+      status: d.status,
+      title: d.title,
+      childCount: coordination.get(d.path)?.childCount ?? 0,
+      nextPickup: coordination.get(d.path)?.nextPickup ?? null,
+      updated: d.updated,
+      nextStep: d.nextStep ?? null,
+    }));
+    process.stdout.write(JSON.stringify({ count: runlists.length, runlists }, null, 2) + '\n');
+    return;
+  }
+
+  if (hubs.length === 0) {
+    process.stdout.write('No runlists found. A runlist is a plan with `execution_mode: coordination` (or a `*-runlist` slug).\n');
+    return;
+  }
+
+  const maxWidth = process.stdout.columns || 100;
+  const shown = hubs.slice(0, limit);
+  renderCoordinationSection(shown, coordination, maxWidth, hubs.length);
+  const hidden = hubs.length - shown.length;
+  if (hidden > 0) process.stdout.write(dim(`  ${hidden} more  ·  dotmd runlists --limit ${hubs.length}\n`));
+  process.stdout.write('\n');
+}
+
 // When a query returns nothing AND a value-shaped filter (currently --module)
 // names a value that doesn't exist anywhere in the index, the empty result is
 // almost certainly a typo rather than a combination miss. Surface a hint so
@@ -254,6 +336,10 @@ export function filterDocs(docs, filters, config) {
     const s = d.status ?? 'unknown';
     filters._statusCounts[s] = (filters._statusCounts[s] ?? 0) + 1;
   }
+  // Keep a reference to the full pre-limit set so the plans header can
+  // reclassify runlist hubs out of the status breakdown (it needs per-doc
+  // identity, not just aggregate counts).
+  filters._matched = result;
   return filters.all ? result : result.slice(0, filters.limit);
 }
 
@@ -394,6 +480,16 @@ function renderPlansOutput(docs, filters, config, opts = {}) {
     return;
   }
 
+  const maxWidth = process.stdout.columns || 100;
+  const grouped = filters.sort === 'status' || filters.group;
+  // Runlist treatment (sprint-hub folding + the coordination-hub section) is
+  // scoped to the flat triage view; grouped views keep their existing shape.
+  const runlist = !grouped ? opts.runlist : null;
+  const coordination = !grouped ? opts.coordination : null;
+  // A doc is a "runlist" for header/section purposes if it's either a
+  // frontmatter-`runlist:` sprint hub or an `execution_mode: coordination` hub.
+  const isHub = (p) => Boolean(runlist?.hubs.has(p) || coordination?.has(p));
+
   // Summary line: middle-dot separator, ALWAYS based on the full pre-limit
   // pipeline so the top-of-page numbers stay honest when --limit is applied.
   const totalShown = docs.length;
@@ -403,9 +499,27 @@ function renderPlansOutput(docs, filters, config, opts = {}) {
     for (const d of docs) { counts[d.status] = (counts[d.status] ?? 0) + 1; }
     return counts;
   })();
-  // Sort statuses by count desc for a stable visual.
-  const counts = Object.entries(bySt).sort((a, b) => b[1] - a[1]).map(([s, n]) => `${n} ${s}`).join(' · ');
-  const header = `${totalAll} ${noun}${counts ? ' · ' + counts : ''}`;
+  // With runlists present, pull hubs out of the per-status breakdown into a
+  // dedicated `N runlist` bucket so a hub reads as an active *runlist*, not one
+  // more active plan. Needs per-doc identity, so recompute from the pre-limit
+  // matched set rather than the aggregate counts.
+  let hubCount = 0;
+  let counts;
+  if ((runlist?.hubs.size || coordination?.size) && filters._matched) {
+    const reclassed = {};
+    for (const d of filters._matched) {
+      if (isHub(d.path)) { hubCount += 1; continue; }
+      const s = d.status ?? 'unknown';
+      reclassed[s] = (reclassed[s] ?? 0) + 1;
+    }
+    counts = Object.entries(reclassed).sort((a, b) => b[1] - a[1]).map(([s, n]) => `${n} ${s}`);
+  } else {
+    counts = Object.entries(bySt).sort((a, b) => b[1] - a[1]).map(([s, n]) => `${n} ${s}`);
+  }
+  const headerParts = [];
+  if (hubCount) headerParts.push(`${hubCount} runlist${hubCount === 1 ? '' : 's'}`);
+  headerParts.push(...counts);
+  const header = `${totalAll} ${noun}${headerParts.length ? ' · ' + headerParts.join(' · ') : ''}`;
   process.stdout.write(dim(header) + '\n');
 
   // Active filter note
@@ -420,9 +534,6 @@ function renderPlansOutput(docs, filters, config, opts = {}) {
   if (filters.hasBlockers) activeFilters.push('has blockers');
   if (activeFilters.length) process.stdout.write(dim(`  filtered: ${activeFilters.join(' | ')}`) + '\n');
 
-  const maxWidth = process.stdout.columns || 100;
-  const grouped = filters.sort === 'status' || filters.group;
-
   if (filters.group === 'module') {
     process.stdout.write('\n');
     renderPlansByGroup(docs, d => d.modules?.length ? d.modules : ['(none)'], filters, maxWidth);
@@ -447,12 +558,47 @@ function renderPlansOutput(docs, filters, config, opts = {}) {
       renderPlanRows(group, filters, maxWidth, { showTag: false });
     }
   } else {
-    // Triage view: flat, sorted by recency, tag on right.
+    // Flat triage view, "capped like leaves": work from the full pre-limit
+    // matched set and cap each kind independently. Leaf plans (+ frontmatter
+    // `runlist:` sprint hubs, which still fold inline) fill the main list;
+    // coordination hubs are lifted into their own `Runlists` section. Each
+    // section caps at `--limit` with its own "N more" footer; `--all` lifts
+    // both caps. The Runlists section is pinned — it shows whenever hubs exist,
+    // independent of how the leaf list fills up.
+    const matched = filters._matched ?? docs;
+    const coordAll = [];
+    const mainAll = [];
+    for (const d of matched) {
+      if (coordination?.has(d.path)) coordAll.push(d);
+      else mainAll.push(d);
+    }
+    const mainShown = filters.all ? mainAll : mainAll.slice(0, filters.limit);
+    const coordShown = filters.all ? coordAll : coordAll.slice(0, filters.limit);
+
     process.stdout.write('\n');
-    renderPlanRows(docs, filters, maxWidth, { showTag: true });
+    if (mainShown.length) {
+      if (runlist?.hubs.size) renderTriageWithRunlists(mainShown, runlist, maxWidth);
+      else renderPlanRows(mainShown, filters, maxWidth, { showTag: true });
+    }
+    const mainHidden = mainAll.length - mainShown.length;
+    if (mainHidden > 0) {
+      process.stdout.write('\n');
+      process.stdout.write(dim(`  ${mainHidden} more ${noun}  ·  dotmd ${noun} --all  ·  dotmd ${noun} status\n`));
+    }
+
+    if (coordShown.length) {
+      renderCoordinationSection(coordShown, coordination, maxWidth, coordAll.length);
+      const coordHidden = coordAll.length - coordShown.length;
+      if (coordHidden > 0) {
+        process.stdout.write(dim(`  ${coordHidden} more runlists  ·  dotmd ${noun} --all\n`));
+      }
+    }
+
+    process.stdout.write('\n');
+    return;
   }
 
-  // Footer when the result was capped — emit for every view shape.
+  // Footer (grouped views) — emit when the result was capped.
   const hidden = totalAll - totalShown;
   if (hidden > 0) {
     process.stdout.write('\n');
@@ -483,49 +629,172 @@ function renderPlansByGroup(docs, keyFn, filters, maxWidth) {
 // next-step column when right-aligning tags.
 const MAX_TAG_WIDTH = '[QUEUED-AFTER]'.length;
 
-function renderPlanRows(group, filters, maxWidth, opts = {}) {
+// Format a single triage row: `<indent><slug>  <age>  <pct>  <next-step>` with
+// an optional right-aligned tag. `indent` carries the left gutter (and, for
+// runlist children, the `→` next-pickup marker), so its visible length must be
+// stable across sibling rows for the slug column to align. `tag` overrides the
+// status tag (used for the `[RUNLIST]` hub tag).
+function formatPlanRow(doc, maxWidth, { slug, indent = '  ', maxSlug, showTag = false, tag } = {}) {
+  const slugCell = slug.padEnd(maxSlug ?? slug.length);
+  const age = doc.daysSinceUpdate != null ? `${doc.daysSinceUpdate}d` : '—';
+  const ageStr = doc.daysSinceUpdate != null && doc.isStale ? red(age.padStart(4)) : dim(age.padStart(4));
+
+  // Compact percentage cell (always 5 chars: "100% " / " 99% " / "  5% " / "     ")
+  let pctCell = '     ';
+  if (doc.checklist?.total) {
+    const pct = Math.round((doc.checklist.completed / doc.checklist.total) * 100);
+    pctCell = `${pct.toString().padStart(3)}% `;
+  }
+
+  const leftBlock = `${indent}${slugCell}  ${ageStr}  ${dim(pctCell)}`;
+  const leftLen = visibleLen(leftBlock);
+
+  // Next-step / blocker text. Budget = maxWidth - leftLen - separator - (tag column if shown).
+  let nextText = '';
+  if (doc.blockers?.length && doc.status === 'blocked') {
+    nextText = `blocked by ${doc.blockers.join('; ')}`;
+  } else if (doc.nextStep) {
+    nextText = doc.nextStep;
+  }
+
+  const tagBudget = showTag ? MAX_TAG_WIDTH + 2 : 0; // 2 = gap before tag
+  const nextBudget = Math.max(10, maxWidth - leftLen - 2 - tagBudget); // -2 for `  ` separator
+  let nextRendered = nextText;
+  if (nextText.length > nextBudget) nextRendered = nextText.slice(0, nextBudget - 3) + '...';
+
+  // Coloring for "blocked by" stays yellow.
+  if (doc.blockers?.length && doc.status === 'blocked') nextRendered = yellow(nextRendered);
+
+  let line = `${leftBlock}  ${nextRendered}`;
+  if (showTag) {
+    // Pad next column to push tag to the right column boundary.
+    const consumed = visibleLen(line);
+    const targetCol = maxWidth - MAX_TAG_WIDTH;
+    const padCount = Math.max(2, targetCol - consumed);
+    line = `${line}${' '.repeat(padCount)}${tag ?? colorTag(doc.status)}`;
+  }
+  return line;
+}
+
+function renderPlanRows(group, _filters, maxWidth, opts = {}) {
   const { showTag = false } = opts;
   const maxSlug = Math.min(30, Math.max(...group.map(d => toSlug(d).length)));
-
   for (const doc of group) {
-    const slug = toSlug(doc).padEnd(maxSlug);
-    const age = doc.daysSinceUpdate != null ? `${doc.daysSinceUpdate}d` : '—';
-    const ageStr = doc.daysSinceUpdate != null && doc.isStale ? red(age.padStart(4)) : dim(age.padStart(4));
+    process.stdout.write(formatPlanRow(doc, maxWidth, { slug: toSlug(doc), maxSlug, showTag }) + '\n');
+  }
+}
 
-    // Compact percentage cell (always 5 chars: "100% " / " 99% " / "  5% " / "     ")
-    let pctCell = '     ';
-    if (doc.checklist?.total) {
-      const pct = Math.round((doc.checklist.completed / doc.checklist.total) * 100);
-      pctCell = `${pct.toString().padStart(3)}% `;
-    }
+const RUNLIST_TAG = bold(cyan('[RUNLIST]'));
 
-    const leftBlock = `  ${slug}  ${ageStr}  ${dim(pctCell)}`;
-    const leftLen = visibleLen(leftBlock);
+// Drop a hub's slug prefix off a child slug so a sprint's children read as
+// `01-extract` rather than `auth-revamp-01-extract`. Falls back to the full
+// slug when there's no shared prefix.
+function stripHubPrefix(childSlug, hubSlug) {
+  return childSlug.startsWith(`${hubSlug}-`) ? childSlug.slice(hubSlug.length + 1) : childSlug;
+}
 
-    // Next-step / blocker text. Budget = maxWidth - leftLen - separator - (tag column if shown).
-    let nextText = '';
-    if (doc.blockers?.length && doc.status === 'blocked') {
-      nextText = `blocked by ${doc.blockers.join('; ')}`;
-    } else if (doc.nextStep) {
-      nextText = doc.nextStep;
-    }
+// Flat triage view, runlist-aware. Standalone plans render as before; each hub
+// becomes a `[RUNLIST]` header with its (filtered) children folded underneath
+// in runlist order, the next pickup marked `→`. A child whose hub is absent
+// from this filtered set (e.g. `--status active` hid the hub) renders
+// standalone so it still surfaces. Render units sort by their most-recent
+// member so an actively-worked sprint stays near the top.
+function renderTriageWithRunlists(docs, runlist, maxWidth) {
+  const { hubs, childToHub } = runlist;
+  const docPathSet = new Set(docs.map(d => d.path));
+
+  const folded = new Set();
+  for (const d of docs) {
+    const hubPath = childToHub.get(d.path);
+    if (hubPath && docPathSet.has(hubPath)) folded.add(d.path);
+  }
 
-    const tagBudget = showTag ? MAX_TAG_WIDTH + 2 : 0; // 2 = gap before tag
-    const nextBudget = Math.max(10, maxWidth - leftLen - 2 - tagBudget); // -2 for `  ` separator
-    let nextRendered = nextText;
-    if (nextText.length > nextBudget) nextRendered = nextText.slice(0, nextBudget - 3) + '...';
-
-    // Coloring for "blocked by" stays yellow.
-    if (doc.blockers?.length && doc.status === 'blocked') nextRendered = yellow(nextRendered);
-
-    let line = `${leftBlock}  ${nextRendered}`;
-    if (showTag) {
-      // Pad next column to push tag to the right column boundary.
-      const consumed = visibleLen(line);
-      const targetCol = maxWidth - MAX_TAG_WIDTH;
-      const padCount = Math.max(2, targetCol - consumed);
-      line = `${line}${' '.repeat(padCount)}${colorTag(doc.status)}`;
+  const units = [];
+  for (const d of docs) {
+    if (folded.has(d.path)) continue; // emitted under its hub
+    const info = hubs.get(d.path);
+    if (info) {
+      const children = docs.filter(c => childToHub.get(c.path) === d.path);
+      const ages = [d.daysSinceUpdate, ...children.map(c => c.daysSinceUpdate)].filter(n => n != null);
+      units.push({ anchor: ages.length ? Math.min(...ages) : Infinity, kind: 'hub', hub: d, info, children });
+    } else {
+      units.push({ anchor: d.daysSinceUpdate ?? Infinity, kind: 'plan', doc: d });
+    }
+  }
+  // Stable sort by most-recent member ascending (docs arrive already sorted by
+  // `updated`, so equal anchors keep their incoming order).
+  units.sort((a, b) => a.anchor - b.anchor);
+
+  // Shared slug width for the left-most rows (standalone plans + hub headers).
+  const topSlugs = units.map(u => u.kind === 'hub' ? toSlug(u.hub) : toSlug(u.doc));
+  const topMaxSlug = Math.min(30, Math.max(...topSlugs.map(s => s.length)));
+
+  for (const u of units) {
+    if (u.kind === 'plan') {
+      process.stdout.write(formatPlanRow(u.doc, maxWidth, { slug: toSlug(u.doc), maxSlug: topMaxSlug, showTag: true }) + '\n');
+    } else {
+      renderHubBlock(u.hub, u.info, u.children, maxWidth, topMaxSlug);
     }
-    process.stdout.write(line + '\n');
+  }
+}
+
+function renderHubBlock(hub, info, children, maxWidth, topMaxSlug) {
+  const hubSlug = toSlug(hub);
+  const nextDoc = info.nextChildPath ? info.children.find(c => c.path === info.nextChildPath)?.doc : null;
+  const nextLabel = nextDoc ? stripHubPrefix(toSlug(nextDoc), hubSlug) : null;
+  const descr = nextLabel
+    ? `runlist · ${info.doneCount}/${info.total} · next → ${nextLabel}`
+    : `runlist · ${info.doneCount}/${info.total} · all archived`;
+
+  // Header row: hub slug + descriptor, with `[RUNLIST]` right-aligned like a tag.
+  const slugCell = hubSlug.padEnd(topMaxSlug);
+  let header = `  ${slugCell}  ${dim(descr)}`;
+  const targetCol = maxWidth - MAX_TAG_WIDTH;
+  const pad = Math.max(2, targetCol - visibleLen(header));
+  header = `${header}${' '.repeat(pad)}${RUNLIST_TAG}`;
+  process.stdout.write(header + '\n');
+
+  if (children.length === 0) return;
+  const childMaxSlug = Math.min(28, Math.max(...children.map(c => stripHubPrefix(toSlug(c), hubSlug).length)));
+  for (const c of children) {
+    const isNext = c.path === info.nextChildPath;
+    const indent = isNext ? `    ${green('→')} ` : '      ';
+    process.stdout.write(formatPlanRow(c, maxWidth, {
+      slug: stripHubPrefix(toSlug(c), hubSlug), indent, maxSlug: childMaxSlug, showTag: true,
+    }) + '\n');
+  }
+}
+
+// Coordination hubs (prose-first runlists) render in their own compact section:
+// label · age · rough related-cluster size · one-line descriptor. No fold, no
+// per-row tag — the section header is the signal. The count is the resolved
+// `related_plans:` cluster, which includes peer/parent runlists, so it's
+// labelled `related` (not `plans`) to stay honest. Status shows only when it's
+// not the expected `active` (e.g. a `partial` hub).
+function renderCoordinationSection(coordDocs, coordination, maxWidth, total) {
+  process.stdout.write(`\n${bold(`Runlists (${total ?? coordDocs.length})`)}\n`);
+  const maxSlug = Math.min(34, Math.max(...coordDocs.map(d => hubLabel(d).length)));
+  for (const doc of coordDocs) {
+    const info = coordination.get(doc.path);
+    const slug = hubLabel(doc).padEnd(maxSlug);
+    const age = doc.daysSinceUpdate != null ? `${doc.daysSinceUpdate}d` : '—';
+    const ageStr = doc.daysSinceUpdate != null && doc.isStale ? red(age.padStart(4)) : dim(age.padStart(4));
+    const count = info?.childCount ? `${String(info.childCount).padStart(2)} related` : '          ';
+    const statusTag = doc.status && doc.status !== 'active' ? ` ${colorTag(doc.status)}` : '';
+    const desc = (doc.nextStep || doc.currentState || doc.title || '').replace(/\s+/g, ' ').trim();
+
+    // Next-pickup (first non-archived ranked child from the body) leads the
+    // description column when one resolves — it's the most actionable cell. Its
+    // status is shown only when it's not the expected `active`.
+    const next = info?.nextPickup;
+    const nextStr = next
+      ? `${green('→')} ${next.label}${next.status && next.status !== 'active' ? dim(` (${next.status})`) : ''}`
+      : '';
+    const nextPart = nextStr ? `${nextStr}  ` : '';
+
+    const left = `  ${slug}  ${ageStr}  ${dim(count)}  `;
+    const budget = Math.max(10, maxWidth - visibleLen(left) - visibleLen(nextPart) - visibleLen(statusTag) - 2);
+    const descR = desc.length > budget ? desc.slice(0, budget - 3) + '...' : desc;
+    process.stdout.write(`${left}${nextPart}${dim(descR)}${statusTag}\n`);
   }
 }

package/src/render.mjs

@@ -5,6 +5,7 @@ import { extractFrontmatter } from './frontmatter.mjs';
 import { summarizeDocBody } from './ai.mjs';
 import { bold, red, yellow, green, dim } from './color.mjs';
 import { categorizeWarnings } from './check-collapse.mjs';
+import { buildCoordinationIndex } from './runlist.mjs';
 
 // Render `currentState` with an `(auto)` prefix when the value was body-scraped
 // rather than read from frontmatter. Lets a reader see at a glance which docs
@@ -322,6 +323,15 @@ export function renderBriefing(index, config) {
   const research = index.docs.filter(d => d.type === 'research');
   const untyped = index.docs.filter(d => !d.type);
 
+  // Coordination hubs (prose-first runlists) are navigation maps, not units of
+  // work — so lift them out of the live-plan status breakdown into their own
+  // `runlists` bucket and drop them from the actionable `>` list, mirroring
+  // `dotmd plans` / `dotmd runlists`. (Sprint `runlist:` hubs stay as ordinary
+  // plans here; their folding treatment is scoped to `dotmd plans`.) On a repo
+  // with no coordination hubs this is a no-op and the output is unchanged.
+  const coordination = buildCoordinationIndex(index, config);
+  const isHub = (p) => coordination.has(p.path);
+
   if (plans.length) {
     // Headline counts LIVE plans first — "30 plans: 25 archived, …" skims as
     // 30 open work items when zero are. "Live" mirrors the `dotmd plans`
@@ -331,17 +341,26 @@ export function renderBriefing(index, config) {
       ...(config.lifecycle?.terminalStatuses ?? []),
     ]);
     const live = plans.filter(p => !closed.has(p.status) && !isArchivedPath(p.path, config));
+    const liveHubs = live.filter(isHub);
     const bySt = {};
-    for (const p of live) { bySt[p.status] = (bySt[p.status] ?? 0) + 1; }
-    const counts = Object.entries(bySt).map(([s, n]) => `${n} ${s}`).join(', ');
+    for (const p of live) { if (isHub(p)) continue; bySt[p.status] = (bySt[p.status] ?? 0) + 1; }
+    // Runlists lead the breakdown (then leaf statuses), and the bucket sums back
+    // to the live total so the headline stays honest.
+    const countParts = [];
+    if (liveHubs.length) countParts.push(`${liveHubs.length} runlist${liveHubs.length === 1 ? '' : 's'}`);
+    countParts.push(...Object.entries(bySt).map(([s, n]) => `${n} ${s}`));
+    const counts = countParts.join(', ');
     const closedCount = plans.length - live.length;
     const closedPart = closedCount ? ` (${closedCount} archived)` : '';
     lines.push(live.length ? `${live.length} live plans${closedPart}: ${counts}` : `0 live plans${closedPart}`);
-    const show = plans.filter(p => p.status === 'in-session' || p.status === 'active');
+    const show = plans.filter(p => (p.status === 'in-session' || p.status === 'active') && !isHub(p));
     for (const p of show) {
       const next = p.nextStep ? `next: ${p.nextStep}` : '(no next step)';
       lines.push(`  > ${path.basename(p.path, '.md')} (${p.status}) ${next}`);
     }
+    if (liveHubs.length) {
+      lines.push(`  ${liveHubs.length} runlist${liveHubs.length === 1 ? '' : 's'} ${dim('· dotmd runlists')}`);
+    }
   }
 
   const parts = [];