@quolu/lattice 0.12.13 → 0.12.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.12.13",
+  "version": "0.12.14",
   "description": "Lattice — phase-aware TODO graph compiler and conflict-aware orchestration runtime",
   "type": "module",
   "license": "MIT",

package/src/todo-gantt-html.mjs

@@ -6,7 +6,7 @@ import {
 } from './todo-markdown-renderer.mjs';
 import { renderTodoGanttSvg, TODO_GANTT_STATUS_PRESENTATION } from './todo-gantt-svg.mjs';
 
-export const TODO_GANTT_RENDERER_VERSION = 'lattice.todo_gantt_renderer.v10';
+export const TODO_GANTT_RENDERER_VERSION = 'lattice.todo_gantt_renderer.v11';
 export const TODO_GANTT_PROSE_MAX_BYTES = 8 * 1024 * 1024;
 export const TODO_GANTT_HTML_MAX_BYTES = 24 * 1024 * 1024;
 
@@ -126,9 +126,9 @@ function normalizeSections(readModel, narratives, anchorOutcomes) {
   return { sections: result, proseBytes };
 }
 
-/** task node key -> the fold node standing in for it, empty when nothing folded. */
+/** Keys of the ToDos the diagram does not draw, empty when nothing was folded. */
 function foldIndex(layout) {
-  return new Map((layout?.folded ?? []).map((entry) => [refKey(entry.task), refKey(entry.fold)]));
+  return new Set((layout?.folded ?? []).map((ref) => refKey(ref)));
 }
 
 function renderTaskIndexEntry(section, lookup) {
@@ -136,15 +136,13 @@ function renderTaskIndexEntry(section, lookup) {
   const status = DOCUMENT_STATUS[section.state.status] ?? { mark: '?', label: '状態不明' };
   const blockedReason = section.state.status === 'blocked'
     ? `<span class="task-index-blocked-reason">— ${escapeHtmlText(section.state.blocked_reason ?? '理由未記録')}</span>` : '';
-  // A folded ToDo keeps its row here — the index is the complete list — and it
-  // selects its OWN detail. Pointing the row at the fold node standing in for it
-  // on the diagram would open nothing: a fold node is not a ToDo, so no detail
-  // panel carries its key.
+  // A ToDo the diagram does not draw keeps its row here — the index is the
+  // complete list — and it selects its own detail, which exists either way.
   const selectKey = key;
   return `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(selectKey)}"><span class="task-index-status status-${escapeHtmlAttribute(section.state.status)}" role="img" aria-label="${escapeHtmlAttribute(status.label)}">${escapeHtmlText(status.mark)}</span><span class="task-index-reference">${escapeHtmlText(taskReference(section, lookup))}</span><strong>${escapeHtmlText(section.task.title)}</strong>${blockedReason}</button></li>`;
 }
 
-function renderTaskIndex(sections, lookup, folds = new Map()) {
+function renderTaskIndex(sections, lookup, folds = new Set()) {
   const plans = [];
   for (const section of sections) {
     let plan = plans.at(-1);
@@ -165,26 +163,6 @@ function renderTaskIndex(sections, lookup, folds = new Map()) {
   }).join('');
 }
 
-/**
- * Detail panel for a fold node.
- *
- * A fold node is the only thing standing on the diagram for the history it
- * summarises, so it must open like any other node — otherwise clicking the
- * folded part of the plan does nothing and the folded ToDos become unreachable.
- */
-function renderFoldDetail(fold, members, lookup) {
-  const laneLabels = fold.lanes.map((lane) => {
-    const entry = lookup.lanes.get(JSON.stringify([fold.ref.plan_key, lane]));
-    return entry === undefined ? lane : `${lane} — ${entry.name}`;
-  });
-  const chain = fold.longest_chain_task_count === 0 ? ''
-    : `<p><strong>構造上の最長依存鎖:</strong> このうち${fold.longest_chain_task_count}工程が乗っています。</p>`;
-  const memberList = members.length === 0
-    ? '<p class="relation-empty">構成工程を復元できませんでした。</p>'
-    : `<ol class="task-index-list">${members.map((section) => renderTaskIndexEntry(section, lookup)).join('')}</ol>`;
-  return `<article class="task-detail fold-detail" data-detail-key="${escapeHtmlAttribute(refKey(fold.ref))}" hidden><header><span class="detail-status status-done">▣ 完走済み（畳み込み）</span><span class="detail-reference">${escapeHtmlText(`${fold.task_count}工程`)}</span></header><h1>完了済み ${escapeHtmlText(String(fold.task_count))}件</h1><p><strong>plan:</strong> <code>${escapeHtmlText(fold.ref.plan_key)}</code></p><p class="detail-category"><strong>カテゴリ:</strong> ${escapeHtmlText(laneLabels.join('、'))}</p>${chain}<p class="fold-note">後続に作業中・未着手の工程が残っていないため、まとめて1個のノードとして描いています。図に全件を描くには <code>lattice todo gantt --scope all</code> を実行してください。</p><section><h2>含まれる工程 ${escapeHtmlText(String(members.length))}件</h2>${memberList}</section></article>`;
-}
-
 function presentationLookup(presentation) {
   return {
     lanes: new Map((presentation?.lanes ?? []).map((lane) => [JSON.stringify([lane.plan_key, lane.lane]), lane])),
@@ -197,7 +175,7 @@ function taskReference(section, lookup) {
   return number === undefined ? `ID ${section.task.task_id}` : `工程 ${number.display_number}`;
 }
 
-function renderRelationList(relations, sectionByKey, lookup, emptyText, folds = new Map()) {
+function renderRelationList(relations, sectionByKey, lookup, emptyText, folds = new Set()) {
   if (relations.length === 0) return `<p class="relation-empty">${escapeHtmlText(emptyText)}</p>`;
   return `<ul class="relation-list">${relations.map((relation) => {
     const targetKey = refKey(relation.ref);
@@ -205,10 +183,9 @@ function renderRelationList(relations, sectionByKey, lookup, emptyText, folds =
     if (target === undefined) return '';
     const join = relation.joinIds.length === 0 ? ''
       : `<span class="relation-kind">合流条件: ${escapeHtmlText(relation.joinIds.join(', '))}</span>`;
-    // Mark the ones the diagram no longer draws separately, so the reader knows
-    // why they cannot find this box on screen.
+    // Say which ones the diagram does not draw, so the reader stops looking.
     const reference = folds.has(targetKey)
-      ? `▣ ${taskReference(target, lookup)}` : taskReference(target, lookup);
+      ? `${taskReference(target, lookup)}（図では非表示）` : taskReference(target, lookup);
     return `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(targetKey)}"><strong>${escapeHtmlText(reference)}</strong><span>${escapeHtmlText(target.task.title)}</span></button>${join}</li>`;
   }).join('')}</ul>`;
 }
@@ -287,25 +264,13 @@ function renderRightPane(sections, layout, presentation, readModel) {
     const readiness = node?.visibility.next_ready
       ? `<p class="readiness-note">ready frontierの一員です。${ready.length > 1 ? '他のready工程と同時dispatchするのが既定です。subsetだけを選ぶ場合は理由を記録してください。' : '現在の唯一の着手候補です。'}</p>`
       : incoming.get(key).length === 0 ? '<p class="readiness-note">登録済みの前提工程はありません。図だけではdispatch可否を判定しません。</p>' : '';
-    // A folded ToDo has no box of its own on the diagram. Say which fold node
-    // stands in for it, and make that node one click away.
-    const foldKey = folds.get(key);
-    const foldedNote = foldKey === undefined ? ''
-      : `<p class="fold-note">この工程は図の上では ▣ 畳み込みノードにまとめられています。<button type="button" class="fold-return" data-select-node-key="${escapeHtmlAttribute(foldKey)}">畳み込みノードを開く</button></p>`;
+    // Say it plainly when the reader will not find this ToDo on the diagram.
+    const foldedNote = !folds.has(key) ? ''
+      : '<p class="fold-note">完走済みのため図には描いていません。図に出すには <code>lattice todo gantt --scope all</code> を実行してください。</p>';
     return `<article class="task-detail" data-detail-key="${escapeHtmlAttribute(key)}" hidden><header><span class="detail-status status-${escapeHtmlAttribute(section.state.status)}">${escapeHtmlText(status.mark)} ${escapeHtmlText(status.label)}</span><span class="detail-reference">${escapeHtmlText(taskReference(section, lookup))}</span></header><h1>${escapeHtmlText(section.task.title)}</h1><p class="detail-category"><strong>カテゴリ:</strong> ${escapeHtmlText(category)}</p>${categoryDescription}<p><strong>正規ID:</strong> <code>${escapeHtmlText(`${section.ref.plan_key}/${section.task.task_id}`)}</code></p>${blockedReason}${readiness}${foldedNote}<section><h2>前提工程</h2>${renderRelationList(incoming.get(key), sectionByKey, lookup, '登録済みの前提工程はありません。', folds)}</section><section><h2>後続工程</h2>${renderRelationList(outgoing.get(key), sectionByKey, lookup, '登録済みの後続工程はありません。', folds)}</section><p class="anchor-status">${escapeHtmlText(anchorText)}</p><details class="task-diagnostics"><summary>開発者向け診断</summary><dl><dt>canonical ref</dt><dd><code>${escapeHtmlText(`${section.ref.project_id}/${section.ref.plan_key}/${section.task.task_id}`)}</code></dd><dt>anchor</dt><dd>${escapeHtmlText(section.anchorOutcome.anchored ? 'verified' : section.anchorOutcome.reason)}</dd></dl></details></article>`;
   }).join('');
-  const membersByFold = new Map();
-  for (const [taskKey, foldKey] of folds) {
-    const section = sectionByKey.get(taskKey);
-    if (section === undefined) continue;
-    if (!membersByFold.has(foldKey)) membersByFold.set(foldKey, []);
-    membersByFold.get(foldKey).push(section);
-  }
-  const foldDetails = (layout.scope?.folds ?? [])
-    .map((fold) => renderFoldDetail(fold, membersByFold.get(refKey(fold.ref)) ?? [], lookup))
-    .join('');
   const taskIndex = renderTaskIndex(sections, lookup, folds);
-  return `<div class="right-toolbar"><button type="button" data-show-overview>概要</button><button type="button" data-show-selected hidden>選択工程へ戻る</button><button type="button" data-show-task-index>元Markdown全文</button></div><div class="right-content">${overview}<div data-right-panel="details" hidden>${details}${foldDetails}</div><section class="task-index" data-right-panel="task-index" hidden><h1>全工程</h1><p>Latticeに登録された全工程を、現在の状態とともに登録順で表示しています。</p>${taskIndex}</section></div>`;
+  return `<div class="right-toolbar"><button type="button" data-show-overview>概要</button><button type="button" data-show-selected hidden>選択工程へ戻る</button><button type="button" data-show-task-index>元Markdown全文</button></div><div class="right-content">${overview}<div data-right-panel="details" hidden>${details}</div><section class="task-index" data-right-panel="task-index" hidden><h1>全工程</h1><p>Latticeに登録された全工程を、現在の状態とともに登録順で表示しています。</p>${taskIndex}</section></div>`;
 }
 
 function renderDiagramLegend(presentation, layout = null) {
@@ -313,9 +278,9 @@ function renderDiagramLegend(presentation, layout = null) {
   const categoryDetails = categories === '' ? '' : `<details class="category-legend"><summary>カテゴリ説明</summary><dl>${categories}</dl></details>`;
   const foldedCount = layout?.scope?.folded_task_count ?? 0;
   const foldChip = foldedCount === 0 ? ''
-    : `<span class="fold-chip">▣ 完走済み ${foldedCount}件を畳んで表示中</span>`;
+    : `<span class="fold-chip">完走済み ${foldedCount}件を非表示</span>`;
   const foldNote = foldedCount === 0 ? ''
-    : `<p class="fold-note">後続に作業中・未着手が残っていない完了工程を、${layout.scope.fold_node_count}個の畳み込みノードへまとめています。生きた工程とその直接の前提工程は必ず展開したままです。全件を描くには <code>lattice todo gantt --scope all</code> を実行してください。総数・進捗・最長依存鎖は畳み込み前の全工程で数えています。</p>`;
+    : '<p class="fold-note">後続に作業中・未着手が残っていない完了工程は図から外しています。生きた工程とその直接の前提工程は必ず描きます。外した工程は右の「全工程」から辿れ、図に出すには <code>lattice todo gantt --scope all</code> を実行してください。総数・進捗・最長依存鎖は外す前の全工程で数えています。</p>';
   return `<div class="diagram-legend" aria-label="工程図の凡例"><span>${statusMarkup('pending', ' 未着手')}</span><span>${statusMarkup('in-progress', ' 作業中')}</span><span>${statusMarkup('done', ' 完了')}</span><span>${statusMarkup('blocked', ' ブロック中')}</span><span>破線枠: ready frontier（同時dispatch推奨）</span><span>太線: 構造上の最長依存鎖</span><span>半円: 非接触の線交差</span><span>黒丸: 論理上の合流</span>${foldChip}${categoryDetails}${foldNote}<p>縦方向は時間ではなく、登録済み依存関係による工程段階です。ready frontierは全件同時dispatchが既定です。未登録の資源・host制約によりsubsetだけを選ぶ場合は理由を記録します。構造上の最長依存鎖は各工程を同じ重みとして数え、実時間・工数・納期を表しません。</p></div>`;
 }
 
@@ -373,17 +338,12 @@ body{display:grid;grid-template-rows:minmax(0,1fr);height:100vh;margin:0;backgro
 .task-index-list{margin:0;padding:0;list-style:none}.task-index-list li+li{margin-top:8px}.task-index-list button{display:grid;width:100%;grid-template-columns:1.5rem auto minmax(0,1fr);gap:4px 8px;align-items:baseline}
 .task-index-status{grid-row:1 / span 2;color:var(--text-secondary);font-size:13.5px;text-align:center}.task-index-status.status-in-progress{color:var(--accent)}.task-index-status.status-done{color:var(--good)}.task-index-status.status-blocked{color:var(--critical)}
 .task-index-reference{color:var(--text-secondary);font-size:12px;white-space:nowrap}.task-index-list strong{font-size:13.5px;font-weight:600;overflow-wrap:anywhere}.task-index-blocked-reason{grid-column:2 / -1;color:var(--text-secondary);font-size:12px;overflow-wrap:anywhere}
-.fold-detail>section{margin-top:16px}.fold-detail h2{margin:0 0 12px;font-size:16px;font-weight:600}
-.fold-return{margin-left:8px;padding:2px 8px;border:1px solid var(--border);border-radius:4px;background:var(--surface-2);color:var(--text-primary);font:500 12px/1.6 system-ui,-apple-system,"Hiragino Sans","Yu Gothic UI",sans-serif;cursor:pointer}
-.fold-return:focus-visible{outline:2px solid var(--text-primary);outline-offset:2px}
 .todo-gantt text{font-family:system-ui,-apple-system,"Hiragino Sans","Yu Gothic UI",sans-serif;pointer-events:none}
 .todo-node .node-surface{fill:var(--surface-2);stroke:var(--border);stroke-width:1}
 .todo-node .node-meta{fill:var(--text-secondary);font-size:12px;font-weight:500}
 .todo-node .node-title{fill:var(--text-primary);font-size:13.5px;font-weight:400}
 .todo-node .node-title-line{font-size:13.5px;font-weight:400}
 .todo-node .status-mark{fill:var(--text-secondary);font-size:13.5px;font-weight:400}
-.folded-node .node-surface{fill:var(--surface-2);stroke:var(--border);stroke-width:2;stroke-dasharray:none}
-.folded-node .node-title,.folded-node .node-meta{fill:var(--text-secondary)}
 .fold-chip{padding:2px 8px;border:1px solid var(--border);border-radius:9999px;background:var(--surface-2);color:var(--text-primary);font-weight:650}
 .fold-note{flex:1 0 100%;margin:4px 0 0;color:var(--text-secondary);font-weight:400}
 .task-index-folded{margin-top:8px}

package/src/todo-gantt-layout.mjs

@@ -403,10 +403,8 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
 
   // Only the geometry stage below sees the narrowed graph.
   const projected = scope === 'all'
-    ? { nodes: full.nodes, edges: full.edges, foldedByKey: new Map(), folds: [], grouping: null }
-    : projectTodoGanttScope({
-      nodes: full.nodes, edges: full.edges, wave: fullWaves.wave, longestChainKeys: longestNodeKeys,
-    });
+    ? { nodes: full.nodes, edges: full.edges, foldedKeys: new Set() }
+    : projectTodoGanttScope({ nodes: full.nodes, edges: full.edges, wave: fullWaves.wave });
   const nodes = projected.nodes;
   const edges = projected.edges;
   const nodesByKey = new Map(nodes.map((node) => [node.key, node]));
@@ -477,19 +475,10 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
       ref: { ...node.ref }, title: node.title, lane: node.lane, status: node.status,
       wave: wave.get(node.key), row: transversePosition.get(node.key), visible,
       visibility: {
-        // A fold node stands in for a finished branch, so it inherits the chain
-        // marking of the ToDos it replaced rather than carrying one of its own.
-        longest_dependency_chain: node.fold === undefined
-          ? longestNodeKeys.has(node.key) : node.fold.longest_chain_task_count > 0,
+        longest_dependency_chain: longestNodeKeys.has(node.key),
         active: node.status === 'in-progress', next_ready: readyKeys.has(node.key),
         selected: false,
       },
-      fold: node.fold === undefined ? null : {
-        task_count: node.fold.task_count,
-        lanes: [...node.fold.lanes],
-        longest_chain_task_count: node.fold.longest_chain_task_count,
-        task_refs: node.fold.task_refs.map((entry) => ({ ...entry })),
-      },
       geometry,
     };
   });
@@ -636,26 +625,14 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     },
     scope: {
       requested: scope,
-      folded_task_count: projected.foldedByKey.size,
-      fold_node_count: projected.folds.length,
-      grouping: projected.grouping,
-      folds: projected.folds.map((entry) => ({
-        ref: { ...entry.ref },
-        task_count: entry.task_count,
-        lanes: [...entry.lanes],
-        longest_chain_task_count: entry.longest_chain_task_count,
-      })),
+      folded_task_count: projected.foldedKeys.size,
     },
-    folded: [...projected.foldedByKey.entries()]
-      .map(([taskKey, foldKey]) => ({ task: JSON.parse(taskKey), fold: JSON.parse(foldKey) }))
-      .sort((left, right) => compareRefs(
-        { project_id: left.task[0], plan_key: left.task[1], task_id: left.task[2] },
-        { project_id: right.task[0], plan_key: right.task[1], task_id: right.task[2] },
-      ))
-      .map(({ task, fold }) => ({
-        task: { project_id: task[0], plan_key: task[1], task_id: task[2] },
-        fold: { project_id: fold[0], plan_key: fold[1], task_id: fold[2] },
-      })),
+    // The ToDos the diagram no longer draws. They stay in the task index and in
+    // every count, so the reader can still reach them by name.
+    folded: [...projected.foldedKeys]
+      .map((taskKey) => JSON.parse(taskKey))
+      .map(([project_id, plan_key, task_id]) => ({ project_id, plan_key, task_id }))
+      .sort(compareRefs),
     metrics: {
       crossing_count: crossingCount(edges, wave, transversePosition),
       visible_node_count: visibleKeys.size,

package/src/todo-gantt-scope.mjs

@@ -9,55 +9,35 @@
  * removed from the store; the diagram is a projection, and this module is
  * where that projection narrows.
  *
- * The rule is "fold the dead branches": a completed ToDo that no longer leads
- * to any live work is history, and history collapses into as few labelled nodes
- * as the graph allows — one per plan when nothing forbids it. Completed ToDos
- * that are still the direct premise of live work stay visible, because they are
- * the context for what is dispatchable right now.
+ * The rule is "drop the dead branches": a completed ToDo that no longer leads
+ * to any live work is history, and history leaves the diagram entirely.
+ * Completed ToDos that are still the direct premise of live work stay visible,
+ * because they are the context for what is dispatchable right now.
  *
- * Grouping by connectivity was tried first and does not compress real plans: a
- * store whose finished ToDos rarely declare dependencies on each other yields
- * one fold unit per ToDo, which draws the same number of boxes as no folding at
- * all while hiding every title. History is grouped by the plan it belongs to,
- * not by whether its members happen to be wired together.
+ * Summarising history into placeholder nodes was tried and is worse than
+ * drawing nothing: a summary box still occupies a column, so the diagram stays
+ * as wide as the finished plans ever made it while saying nothing a reader
+ * acts on. The count belongs in the legend and the ToDos themselves belong in
+ * the task index; neither needs floor space in the graph.
  *
  * This module is pure graph math over the layout's internal node/edge shape.
  * It must run AFTER dependency waves, the longest dependency chain and the
  * ready frontier have been computed on the FULL graph — those numbers describe
- * the real plan, and measuring them on a folded graph would make them lie.
+ * the real plan, and measuring them on a narrowed graph would make them lie.
  */
 
 export const TODO_GANTT_SCOPES = Object.freeze(['live', 'all']);
 
 /**
  * Hops of completed predecessors kept in front of live work. 1 = keep the
- * direct premises of live ToDos, fold everything upstream of them.
+ * direct premises of live ToDos, drop everything upstream of them.
  */
 export const DEFAULT_FOLD_DISTANCE = 1;
 
-/**
- * `task_id` values in the store match /^[0-9A-Za-z][0-9A-Za-z._-]{0,127}$/, so
- * a leading '~' cannot collide with a real ToDo.
- */
-const FOLD_TASK_ID_PREFIX = '~folded';
-
-export class TodoGanttScopeError extends Error {
-  constructor(code, message, detail = null) {
-    super(message);
-    this.name = 'TodoGanttScopeError';
-    this.code = code;
-    this.detail = detail;
-  }
-}
-
 function compareText(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-export function isFoldNodeRef(ref) {
-  return typeof ref?.task_id === 'string' && ref.task_id.startsWith(`${FOLD_TASK_ID_PREFIX}:`);
-}
-
 /**
  * Forward distance from each node to the nearest live (non-done) node, over the
  * dependency DAG. A live node is at distance 0; a node with no live descendant
@@ -88,226 +68,27 @@ function distanceToLive(nodes, edges, wave) {
   return distance;
 }
 
-function foldableKeys(nodes, distance, foldDistance) {
-  return new Set(nodes
-    .filter((node) => node.status === 'done' && distance.get(node.key) > foldDistance)
-    .map(({ key }) => key));
-}
-
-/**
- * Grouping strategies, coarsest first. The projection takes the first one whose
- * contraction stays acyclic.
- *
- * - `plan`: one fold unit per plan. All history of a finished plan becomes one
- *   node. This is the target shape and it is what a reader wants to see.
- * - `plan_stage`: additionally split per kept-node depth. A cycle can only close
- *   through a node kept on screen, and that axis is exactly what `keptDepth`
- *   measures, so this is the smallest refinement that removes the usual cause.
- * - `plan_wave`: additionally split per dependency wave. Provably acyclic —
- *   every dependency edge strictly increases the wave, so a contracted edge
- *   between two units always increases it too and no cycle can exist.
- */
-const GROUPING_LADDER = Object.freeze(['plan', 'plan_stage', 'plan_wave']);
-
-/**
- * Number of kept (non-foldable) nodes lying before each node on the longest
- * path. Crossing a kept node strictly increases it; edges between two foldable
- * nodes leave it unchanged.
- *
- * Edges always increase the wave (`assignWaves` is a longest-path layering), so
- * visiting nodes in ascending wave order settles every predecessor first.
- */
-function keptDepth(nodes, edges, foldable, wave) {
-  const incoming = new Map(nodes.map(({ key }) => [key, []]));
-  for (const edge of edges) incoming.get(edge.to).push(edge.from);
-  const depth = new Map();
-  const ordered = [...nodes].sort((left, right) => wave.get(left.key) - wave.get(right.key)
-    || compareText(left.key, right.key));
-  for (const node of ordered) {
-    let best = 0;
-    for (const predecessor of incoming.get(node.key)) {
-      const settled = depth.get(predecessor);
-      if (settled === undefined) continue;
-      const candidate = settled + (foldable.has(predecessor) ? 0 : 1);
-      if (candidate > best) best = candidate;
-    }
-    depth.set(node.key, best);
-  }
-  return depth;
-}
-
-/** Group foldable nodes into fold units under one of `GROUPING_LADDER`. */
-function groupFoldable(nodes, foldable, strategy, axes) {
-  const nodeByKey = new Map(nodes.map((node) => [node.key, node]));
-  // A fold unit never spans plans: the diagram groups by plan and a unit that
-  // straddled two plans would have no honest lane to sit in.
-  const axisOf = (key) => (strategy === 'plan' ? null
-    : strategy === 'plan_stage' ? axes.stage.get(key)
-      : axes.wave.get(key));
-  const unitByNode = new Map();
-  const members = new Map();
-  for (const key of [...foldable].sort(compareText)) {
-    const unitKey = JSON.stringify([nodeByKey.get(key).ref.plan_key, axisOf(key)]);
-    unitByNode.set(key, unitKey);
-    if (!members.has(unitKey)) members.set(unitKey, []);
-    members.get(unitKey).push(key);
-  }
-  return { unitByNode, members };
-}
-
-function dominantLane(memberNodes) {
-  const counts = new Map();
-  for (const node of memberNodes) counts.set(node.lane, (counts.get(node.lane) ?? 0) + 1);
-  return [...counts.entries()]
-    .sort(([leftLane, leftCount], [rightLane, rightCount]) => rightCount - leftCount
-      || compareText(leftLane, rightLane))[0][0];
-}
-
-function buildSummaryNodes(nodes, members, longestChainKeys) {
-  const nodeByKey = new Map(nodes.map((node) => [node.key, node]));
-  // Order fold units by their first member so synthetic ids are stable across runs.
-  const ordered = [...members.entries()]
-    .map(([unitKey, memberKeys]) => ({ unitKey, memberKeys: [...memberKeys].sort(compareText) }))
-    .sort((left, right) => compareText(left.memberKeys[0], right.memberKeys[0]));
-
-  const summaryByUnit = new Map();
-  ordered.forEach((unit, index) => {
-    const memberNodes = unit.memberKeys.map((key) => nodeByKey.get(key));
-    const { plan_key: planKey, project_id: projectId } = memberNodes[0].ref;
-    const ref = { project_id: projectId, plan_key: planKey, task_id: `${FOLD_TASK_ID_PREFIX}:${index}` };
-    const key = JSON.stringify([ref.project_id, ref.plan_key, ref.task_id]);
-    const lanes = [...new Set(memberNodes.map((node) => node.lane))].sort(compareText);
-    summaryByUnit.set(unit.unitKey, {
-      key,
-      ref,
-      title: `完了済み ${memberNodes.length}件`,
-      lane: dominantLane(memberNodes),
-      status: 'done',
-      plan_schema: memberNodes[0].plan_schema,
-      phase_id: null,
-      phase_status: null,
-      phase_ready: false,
-      fold: {
-        task_count: memberNodes.length,
-        lanes,
-        longest_chain_task_count: memberNodes
-          .filter((node) => longestChainKeys.has(node.key)).length,
-        task_refs: memberNodes.map((node) => ({ ...node.ref })),
-      },
-    });
-  });
-  return summaryByUnit;
-}
-
-function contract(nodes, edges, unitByNode, summaryByUnit) {
-  const mapKey = (key) => {
-    const unitKey = unitByNode.get(key);
-    return unitKey === undefined ? key : summaryByUnit.get(unitKey).key;
-  };
-  const keptNodes = nodes.filter((node) => !unitByNode.has(node.key));
-  const summaries = [...summaryByUnit.values()];
-  const resultNodes = [...keptNodes, ...summaries]
-    .sort((left, right) => compareText(left.key, right.key));
-
-  const contracted = new Map();
-  for (const edge of edges) {
-    const from = mapKey(edge.from);
-    const to = mapKey(edge.to);
-    if (from === to) continue; // interior of a fold unit
-    const key = JSON.stringify([from, to]);
-    let merged = contracted.get(key);
-    if (merged === undefined) {
-      // A rewired edge is an aggregate. Join identity describes how several
-      // premises meet at one ToDo; carrying it onto an aggregate edge would
-      // draw a junction marker for a join whose members are no longer on
-      // screen, so aggregates keep only the dependency kinds.
-      merged = { key, from, to, kinds: new Set(), joinIdentities: new Map(), aggregated: false };
-      contracted.set(key, merged);
-    }
-    for (const kind of edge.kinds) merged.kinds.add(kind);
-    if (from === edge.from && to === edge.to) {
-      for (const [identityKey, identity] of edge.joinIdentities) {
-        merged.joinIdentities.set(identityKey, identity);
-      }
-    } else {
-      merged.aggregated = true;
-    }
-  }
-  for (const edge of contracted.values()) {
-    if (edge.aggregated) edge.joinIdentities = new Map();
-  }
-  const resultEdges = [...contracted.values()].sort((left, right) => compareText(left.key, right.key));
-  return { nodes: resultNodes, edges: resultEdges };
-}
-
-/** Kahn peel; returns true when the graph is acyclic. */
-function isAcyclic(nodes, edges) {
-  const indegree = new Map(nodes.map(({ key }) => [key, 0]));
-  const outgoing = new Map(nodes.map(({ key }) => [key, []]));
-  for (const edge of edges) {
-    outgoing.get(edge.from).push(edge.to);
-    indegree.set(edge.to, indegree.get(edge.to) + 1);
-  }
-  const ready = nodes.filter(({ key }) => indegree.get(key) === 0).map(({ key }) => key);
-  let visited = 0;
-  while (ready.length > 0) {
-    const current = ready.pop();
-    visited += 1;
-    for (const next of outgoing.get(current)) {
-      indegree.set(next, indegree.get(next) - 1);
-      if (indegree.get(next) === 0) ready.push(next);
-    }
-  }
-  return visited === nodes.length;
-}
-
 /**
  * Project the full dependency graph onto the `live` scope.
  *
- * Contraction can close a cycle: with a fold distance of 1 the shape
- * `f1 -> s -> f2` is reachable, where `s` is a completed ToDo kept as the direct
- * premise of live work and `f1`/`f2` land in the same fold unit. Contracting
- * that unit would produce `summary -> s -> summary`. So each candidate grouping
- * is verified and the coarsest acyclic one wins. The last rung is provably
- * acyclic, so the throw below is a backstop, never a routine outcome.
+ * Removing nodes from a DAG cannot create a cycle, so the narrowed graph needs
+ * no verification: what is left is a subgraph of what was already acyclic.
  *
- * @returns {{nodes: Array, edges: Array, foldedByKey: Map, folds: Array, grouping: string}}
+ * @returns {{nodes: Array, edges: Array, foldedKeys: Set<string>}}
  */
 export function projectTodoGanttScope({
-  nodes, edges, wave, longestChainKeys = new Set(), foldDistance = DEFAULT_FOLD_DISTANCE,
+  nodes, edges, wave, foldDistance = DEFAULT_FOLD_DISTANCE,
 }) {
   const distance = distanceToLive(nodes, edges, wave);
-  const foldable = foldableKeys(nodes, distance, foldDistance);
-  if (foldable.size === 0) {
-    return { nodes, edges, foldedByKey: new Map(), folds: [], grouping: null };
-  }
-
-  const axes = { wave, stage: keptDepth(nodes, edges, foldable, wave) };
-  let selected = null;
-  for (const strategy of GROUPING_LADDER) {
-    const grouping = groupFoldable(nodes, foldable, strategy, axes);
-    const summaryByUnit = buildSummaryNodes(nodes, grouping.members, longestChainKeys);
-    const contracted = contract(nodes, edges, grouping.unitByNode, summaryByUnit);
-    if (!isAcyclic(contracted.nodes, contracted.edges)) continue;
-    selected = { strategy, grouping, summaryByUnit, contracted };
-    break;
-  }
-  if (selected === null) {
-    throw new TodoGanttScopeError('TODO_SCOPE_CONTRACTION_CYCLIC',
-      'todo gantt scope contraction produced a cycle under every grouping',
-      { attempted_groupings: [...GROUPING_LADDER] });
-  }
-  const { grouping, summaryByUnit, contracted } = selected;
-
-  const foldedByKey = new Map();
-  for (const [nodeKey, unitKey] of grouping.unitByNode) {
-    foldedByKey.set(nodeKey, summaryByUnit.get(unitKey).key);
-  }
-  const folds = [...summaryByUnit.values()]
-    .sort((left, right) => compareText(left.key, right.key))
-    .map((summary) => ({ ref: { ...summary.ref }, ...summary.fold }));
-
+  const foldedKeys = new Set(nodes
+    .filter((node) => node.status === 'done' && distance.get(node.key) > foldDistance)
+    .map(({ key }) => key));
+  if (foldedKeys.size === 0) return { nodes, edges, foldedKeys };
   return {
-    nodes: contracted.nodes, edges: contracted.edges, foldedByKey, folds, grouping: selected.strategy,
+    nodes: nodes.filter((node) => !foldedKeys.has(node.key)),
+    // An edge with a dropped endpoint goes with it. The kept node keeps its
+    // real premises in the right pane, which reads the full graph.
+    edges: edges.filter((edge) => !foldedKeys.has(edge.from) && !foldedKeys.has(edge.to)),
+    foldedKeys,
   };
 }

package/src/todo-gantt-svg.mjs

@@ -140,31 +140,23 @@ function presentationMaps(presentation) {
 function renderNode(node, maps) {
   if (!node.visible || node.geometry === null) return '';
   const { x, y, width, height } = node.geometry;
-  const fold = node.fold ?? null;
   const classes = ['todo-node', STATUS_CLASSES[node.status] ?? 'status-unknown'];
-  if (fold !== null) classes.push('folded-node');
   if (node.visibility.longest_dependency_chain) classes.push('longest-chain-node');
   if (node.visibility.active) classes.push('active-node');
   if (node.visibility.next_ready) classes.push('next-ready-node');
   if (node.visibility.selected) classes.push('selected-node');
   const key = nodeKey(node.ref);
   const nodeLaneKey = laneKey(node.ref.plan_key, node.lane);
-  const status = fold === null
-    ? TODO_GANTT_STATUS_PRESENTATION[node.status] ?? { mark: '?', label: '状態不明' }
-    : { mark: '▣', label: '完走済み（畳み込み）' };
+  const status = TODO_GANTT_STATUS_PRESENTATION[node.status] ?? { mark: '?', label: '状態不明' };
   const lane = maps.lanes.get(nodeLaneKey);
-  const laneLabel = fold === null
-    ? (lane === undefined ? node.lane : `${node.lane}、${lane.name}`)
-    : fold.lanes.join('、');
+  const laneLabel = lane === undefined ? node.lane : `${node.lane}、${lane.name}`;
   const taskNumber = maps.taskNumbers.get(key);
-  const visibleReference = fold !== null ? `${fold.task_count}工程`
-    : taskNumber === undefined ? `ID ${node.ref.task_id}` : `工程 ${taskNumber.display_number}`;
-  const spokenReference = fold !== null ? `${fold.task_count}工程の畳み込み`
-    : taskNumber === undefined ? `ID ${node.ref.task_id}` : `工程${taskNumber.display_number}`;
+  const visibleReference = taskNumber === undefined
+    ? `ID ${node.ref.task_id}` : `工程 ${taskNumber.display_number}`;
+  const spokenReference = taskNumber === undefined
+    ? `ID ${node.ref.task_id}` : `工程${taskNumber.display_number}`;
   const readyLabel = node.visibility.next_ready ? '。ready frontierの同時dispatch候補' : '';
-  const identity = fold === null
-    ? `正規ID ${node.ref.plan_key}/${node.ref.task_id}`
-    : `${node.ref.plan_key}の完走済み${fold.task_count}工程をまとめたノード。全件を描くには --scope all`;
+  const identity = `正規ID ${node.ref.plan_key}/${node.ref.task_id}`;
   const ariaLabel = `${spokenReference}。${status.label}。${laneLabel}。${node.title}。${identity}${readyLabel}`;
   const statusBar = node.status === 'in-progress'
     ? `<line class="status-bar" x1="${x + 5}" y1="${y + 6}" x2="${x + 5}" y2="${y + height - 6}"></line>` : '';
@@ -186,8 +178,15 @@ function summaryChipWidth(label, minimum = 116) {
 function renderTodoSummary(layout, maps) {
   const markup = [];
   let groupX = 16;
-  for (const plan of layout.groups.plans) {
-    const lanes = layout.groups.lanes.filter((lane) => lane.plan_key === plan.plan_key);
+  // The band is a header for the diagram, so it covers what the diagram draws.
+  // Keeping a chip for every lane of every finished plan stretched the canvas to
+  // several times the width of the graph itself, all of it empty columns.
+  // The chips still count every ToDo in the lane, folded ones included.
+  const drawnPlans = new Set(layout.nodes.map((node) => node.ref.plan_key));
+  const drawnLanes = new Set(layout.nodes.map((node) => laneKey(node.ref.plan_key, node.lane)));
+  for (const plan of layout.groups.plans.filter(({ plan_key }) => drawnPlans.has(plan_key))) {
+    const lanes = layout.groups.lanes.filter((lane) => lane.plan_key === plan.plan_key
+      && drawnLanes.has(laneKey(lane.plan_key, lane.lane)));
     const laneChips = lanes.map((lane) => {
       const metadata = maps.lanes.get(laneKey(lane.plan_key, lane.lane));
       const fullLabel = metadata === undefined