@quolu/lattice 0.12.12 → 0.12.14

package/package.json

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

package/src/todo-dashboard-registry.mjs

@@ -6,6 +6,16 @@ import {
 } from 'node:fs/promises';
 import path from 'node:path';
 
+import packageJson from '../package.json' with { type: 'json' };
+
+/**
+ * The version of the code in THIS process. A daemon loads its modules once at
+ * startup and keeps serving them, so installing a new package does not change
+ * what the running daemon serves. The daemon reports the version it started
+ * with; anything else is code that has already been replaced on disk.
+ */
+export const TODO_DASHBOARD_CODE_VERSION = packageJson.version;
+
 const REGISTRY_SCHEMA = 'lattice.todo_dashboard_registry.v1';
 const DAEMON_SCHEMA = 'lattice.todo_dashboard_daemon.v1';
 const DEFAULT_PORT = 0;
@@ -182,7 +192,13 @@ async function daemonAttestation(descriptor, { timeoutMs = 2_000 } = {}) {
     if (body?.schema !== 'lattice.todo_dashboard_health.v1' || body.pid !== descriptor.pid
       || !Array.isArray(body.project_ids)) return null;
     const keys = Object.keys(body).sort().join(',');
-    if (keys === 'pid,port,project_ids,schema' && body.port === descriptor.port) return 'current';
+    // 'legacy' means "alive, but serving code we have already replaced" — the
+    // caller starts a replacement and stops it. A daemon that predates the
+    // version field, or one still running an older package, is exactly that.
+    if (keys === 'pid,port,project_ids,schema,version' && body.port === descriptor.port) {
+      return body.version === TODO_DASHBOARD_CODE_VERSION ? 'current' : 'legacy';
+    }
+    if (keys === 'pid,port,project_ids,schema' && body.port === descriptor.port) return 'legacy';
     if (keys === 'pid,project_ids,schema') return 'legacy';
     return null;
   } catch { return null; }

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.v9';
+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,23 +126,23 @@ 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, folds) {
+function renderTaskIndexEntry(section, lookup) {
   const key = refKey(section.ref);
   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 — but
-  // selecting it points at the fold node that actually stands on the diagram.
-  const selectKey = folds.get(key) ?? 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);
@@ -156,9 +156,9 @@ function renderTaskIndex(sections, lookup, folds = new Map()) {
     const drawn = plan.tasks.filter((section) => !folds.has(refKey(section.ref)));
     const folded = plan.tasks.filter((section) => folds.has(refKey(section.ref)));
     const drawnList = drawn.length === 0 ? ''
-      : `<ol class="task-index-list">${drawn.map((section) => renderTaskIndexEntry(section, lookup, folds)).join('')}</ol>`;
+      : `<ol class="task-index-list">${drawn.map((section) => renderTaskIndexEntry(section, lookup)).join('')}</ol>`;
     const foldedList = folded.length === 0 ? ''
-      : `<details class="task-index-folded"><summary>完走済みとして畳んだ工程 ${folded.length}件</summary><ol class="task-index-list">${folded.map((section) => renderTaskIndexEntry(section, lookup, folds)).join('')}</ol></details>`;
+      : `<details class="task-index-folded"><summary>完走済みとして畳んだ工程 ${folded.length}件</summary><ol class="task-index-list">${folded.map((section) => renderTaskIndexEntry(section, lookup)).join('')}</ol></details>`;
     return `<section class="task-index-plan"><h2><code>${escapeHtmlText(plan.planKey)}</code></h2>${drawnList}${foldedList}</section>`;
   }).join('');
 }
@@ -175,14 +175,18 @@ function taskReference(section, lookup) {
   return number === undefined ? `ID ${section.task.task_id}` : `工程 ${number.display_number}`;
 }
 
-function renderRelationList(relations, sectionByKey, lookup, emptyText) {
+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 target = sectionByKey.get(refKey(relation.ref));
+    const targetKey = refKey(relation.ref);
+    const target = sectionByKey.get(targetKey);
     if (target === undefined) return '';
     const join = relation.joinIds.length === 0 ? ''
       : `<span class="relation-kind">合流条件: ${escapeHtmlText(relation.joinIds.join(', '))}</span>`;
-    return `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(refKey(target.ref))}"><strong>${escapeHtmlText(taskReference(target, lookup))}</strong><span>${escapeHtmlText(target.task.title)}</span></button>${join}</li>`;
+    // Say which ones the diagram does not draw, so the reader stops looking.
+    const reference = folds.has(targetKey)
+      ? `${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>`;
 }
 
@@ -211,6 +215,7 @@ function renderRightPane(sections, layout, presentation, readModel) {
   const lookup = presentationLookup(presentation);
   const sectionByKey = new Map(sections.map((section) => [refKey(section.ref), section]));
   const nodeByKey = new Map(layout.nodes.map((node) => [refKey(node.ref), node]));
+  const folds = foldIndex(layout);
   const incoming = new Map(sections.map((section) => [refKey(section.ref), []]));
   const outgoing = new Map(sections.map((section) => [refKey(section.ref), []]));
   const addRelation = (relations, ownerKey, ref, joinIds) => {
@@ -223,7 +228,10 @@ function renderRightPane(sections, layout, presentation, readModel) {
     }
     entry.joinIds = [...new Set([...entry.joinIds, ...joinIds])].sort();
   };
-  for (const edge of layout.edges) {
+  // Premises and successors come from the FULL graph. `layout.edges` is the
+  // drawn graph, where a fold unit's interior dependencies have been contracted
+  // away — reading those here would tell a folded ToDo it has no premises.
+  for (const edge of layout.full_edges ?? layout.edges) {
     addRelation(incoming, refKey(edge.to), edge.from, edge.join_ids);
     addRelation(outgoing, refKey(edge.from), edge.to, edge.join_ids);
   }
@@ -256,9 +264,12 @@ 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>' : '';
-    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}<section><h2>前提工程</h2>${renderRelationList(incoming.get(key), sectionByKey, lookup, '登録済みの前提工程はありません。')}</section><section><h2>後続工程</h2>${renderRelationList(outgoing.get(key), sectionByKey, lookup, '登録済みの後続工程はありません。')}</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>`;
+    // 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 taskIndex = renderTaskIndex(sections, lookup, foldIndex(layout));
+  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}</div><section class="task-index" data-right-panel="task-index" hidden><h1>全工程</h1><p>Latticeに登録された全工程を、現在の状態とともに登録順で表示しています。</p>${taskIndex}</section></div>`;
 }
 
@@ -267,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>`;
 }
 
@@ -333,8 +344,6 @@ body{display:grid;grid-template-rows:minmax(0,1fr);height:100vh;margin:0;backgro
 .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: [], refined: false }
-    : 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,
     };
   });
@@ -619,6 +608,16 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     },
     nodes: projectedNodes,
     edges: projectedEdges,
+    // Every dependency in the plan, before folding contracted any of them away.
+    // The diagram draws `edges`; anything that describes a ToDo in words — the
+    // premises and successors in the right pane — reads this instead, so a
+    // folded ToDo keeps telling the truth about what it depended on.
+    full_edges: full.edges.map((edge) => ({
+      from: { ...full.nodesByKey.get(edge.from).ref },
+      to: { ...full.nodesByKey.get(edge.to).ref },
+      kinds: [...edge.kinds].sort(compareText),
+      join_ids: [...edge.joinIdentities.values()].map(({ join_id }) => join_id).sort(compareText),
+    })),
     connectors: junctionConnectors,
     groups: {
       plans: [...planMap.entries()].map(([plan_key, task_count]) => ({ plan_key, task_count })),
@@ -626,26 +625,14 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     },
     scope: {
       requested: scope,
-      folded_task_count: projected.foldedByKey.size,
-      fold_node_count: projected.folds.length,
-      per_wave_refinement: projected.refined,
-      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-live.mjs

@@ -1,5 +1,7 @@
 import { createServer } from 'node:http';
 
+import { TODO_DASHBOARD_CODE_VERSION } from './todo-dashboard-registry.mjs';
+
 const LOOPBACK = '127.0.0.1';
 const POLL_MS = 500;
 const HTTP_ERROR_SCHEMA = 'lattice.todo_gantt_http_error.v1';
@@ -136,8 +138,12 @@ export async function startTodoGanttDashboardServer({ registry, port = 0, redire
       if (url.pathname === '/__lattice/health') {
         response.writeHead(200, { 'content-type': 'application/json; charset=utf-8',
           'cache-control': 'no-store', 'x-content-type-options': 'nosniff' });
+        // `version` is the package this process loaded at startup, not the one
+        // installed on disk. That difference is the whole point: it is how a
+        // caller learns the daemon is serving code that has been superseded.
         response.end(`${JSON.stringify({ schema: 'lattice.todo_dashboard_health.v1', pid: process.pid,
-          port: actualPort, project_ids: registry.list().map(({ projectId }) => projectId) })}\n`);
+          port: actualPort, project_ids: registry.list().map(({ projectId }) => projectId),
+          version: TODO_DASHBOARD_CODE_VERSION })}\n`);
         return;
       }
       if (url.pathname === '/' || url.pathname === '/projects/') {

package/src/todo-gantt-scope.mjs

@@ -9,49 +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 one labelled node
- * per finished branch. 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.
+ *
+ * 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
@@ -82,215 +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));
-}
-
-/**
- * Group foldable nodes into fold units.
- *
- * `byComponent` groups each weakly connected component of the foldable subgraph
- * into one unit — the compact projection, one node per finished branch.
- * `byComponentAndWave` additionally splits each component per dependency wave.
- * The latter is always acyclic once contracted (every dependency edge strictly
- * increases the wave, so contracted edges do too), which makes it the
- * guaranteed-safe refinement when contraction would otherwise close a cycle.
- */
-function groupFoldable(nodes, edges, foldable, wave, splitByWave) {
-  const parent = new Map([...foldable].map((key) => [key, key]));
-  const find = (key) => {
-    let root = key;
-    while (parent.get(root) !== root) root = parent.get(root);
-    let cursor = key;
-    while (parent.get(cursor) !== root) {
-      const next = parent.get(cursor);
-      parent.set(cursor, root);
-      cursor = next;
-    }
-    return root;
-  };
-  const union = (left, right) => {
-    const leftRoot = find(left);
-    const rightRoot = find(right);
-    if (leftRoot === rightRoot) return;
-    if (compareText(leftRoot, rightRoot) <= 0) parent.set(rightRoot, leftRoot);
-    else parent.set(leftRoot, rightRoot);
-  };
-  const nodeByKey = new Map(nodes.map((node) => [node.key, node]));
-  for (const edge of edges) {
-    if (!foldable.has(edge.from) || !foldable.has(edge.to)) continue;
-    // 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.
-    if (nodeByKey.get(edge.from).ref.plan_key !== nodeByKey.get(edge.to).ref.plan_key) continue;
-    union(edge.from, edge.to);
-  }
-
-  const unitByNode = new Map();
-  const members = new Map();
-  for (const key of [...foldable].sort(compareText)) {
-    const unitKey = splitByWave
-      ? JSON.stringify([find(key), wave.get(key)])
-      : JSON.stringify([find(key), null]);
-    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.
  *
- * Contracting a weakly connected component 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` belong
- * to the same fold unit. Contracting that unit would produce
- * `summary -> s -> summary`. So the contraction is verified, and on a cycle the
- * grouping is refined to (component, wave) — provably acyclic, because every
- * dependency edge strictly increases the wave.
+ * 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, refined: boolean}}
+ * @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: [], refined: false };
-  }
-
-  let refined = false;
-  let grouping = groupFoldable(nodes, edges, foldable, wave, false);
-  let summaryByUnit = buildSummaryNodes(nodes, grouping.members, longestChainKeys);
-  let contracted = contract(nodes, edges, grouping.unitByNode, summaryByUnit);
-  if (!isAcyclic(contracted.nodes, contracted.edges)) {
-    refined = true;
-    grouping = groupFoldable(nodes, edges, foldable, wave, true);
-    summaryByUnit = buildSummaryNodes(nodes, grouping.members, longestChainKeys);
-    contracted = contract(nodes, edges, grouping.unitByNode, summaryByUnit);
-    if (!isAcyclic(contracted.nodes, contracted.edges)) {
-      throw new TodoGanttScopeError('TODO_SCOPE_CONTRACTION_CYCLIC',
-        'todo gantt scope contraction produced a cycle after per-wave refinement',
-        { fold_unit_count: grouping.members.size });
-    }
-  }
-
-  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 }));
-
-  return { nodes: contracted.nodes, edges: contracted.edges, foldedByKey, folds, refined };
+  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: 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