@quolu/lattice 0.12.10 → 0.12.12

package/src/todo-cli.mjs

@@ -20,6 +20,7 @@ import { projectTodoChainV1 } from './todo-chain.mjs';
 import { ensureTodoDashboardActivity } from './todo-dashboard-registry.mjs';
 import { resolveProjectIdentity } from './project-identity.mjs';
 import { layoutTodoGantt } from './todo-gantt-layout.mjs';
+import { TODO_GANTT_SCOPES } from './todo-gantt-scope.mjs';
 import { loadTodoGanttPresentation } from './todo-gantt-presentation.mjs';
 import { startTodoGanttLiveServer } from './todo-gantt-live.mjs';
 import {
@@ -55,6 +56,7 @@ const CLI_ERROR_SCHEMA = 'lattice.cli_error.v2';
 const DEFAULT_GANTT_REF = '.lattice/generated/gantt.html';
 const GANTT_DESCRIPTOR_SUFFIX = '.status.json';
 const MAX_GANTT_DESCRIPTOR_BYTES = 65_536;
+const DEFAULT_GANTT_SCOPE = 'live';
 const MAX_MIGRATION_INPUT_BYTES = 8_388_608;
 const ACTOR_ENV_KEYS = Object.freeze([
   'LATTICE_TODO_ACTOR_HOST',
@@ -596,15 +598,19 @@ function ganttDescriptorRef(outputRef) {
   return `${outputRef}${GANTT_DESCRIPTOR_SUFFIX}`;
 }
 
+// v2 records the scope the artifact was drawn at. Without it `gantt status`
+// would re-render at the default scope and report a `--scope all` artifact as
+// stale even though nothing in the store had moved.
 function validateGanttArtifactDescriptor(value) {
   return exactRecord(value, [
     'schema', 'project_id', 'output_ref', 'manifest_digest', 'renderer_version',
-    'html_digest', 'artifact_digest',
-  ]) && value.schema === 'lattice.todo_gantt_artifact.v1'
+    'scope', 'html_digest', 'artifact_digest',
+  ]) && value.schema === 'lattice.todo_gantt_artifact.v2'
     && isTodoIdentifier(value.project_id) && isTodoRef(value.output_ref)
     && isTodoDigest(value.manifest_digest)
     && typeof value.renderer_version === 'string'
     && /^lattice\.todo_gantt_renderer\.v[1-9][0-9]*$/u.test(value.renderer_version)
+    && TODO_GANTT_SCOPES.includes(value.scope)
     && isTodoDigest(value.html_digest) && isTodoDigest(value.artifact_digest)
     && value.artifact_digest === todoSelfDigest(value, 'artifact_digest');
 }
@@ -636,6 +642,7 @@ function parseGanttDescriptor(bytes, descriptorRef) {
 
 export async function renderTodoGanttForProject({
   repoRoot, stable = false, displayName = null, env = process.env, readModel = null,
+  scope = DEFAULT_GANTT_SCOPE,
 }) {
   const store = readModel
     ?? (stable ? await readTodoStoreStable({ repoRoot }) : await readTodoStore({ repoRoot }));
@@ -645,7 +652,7 @@ export async function renderTodoGanttForProject({
   const presentation = await loadTodoGanttPresentation({ repoRoot, readModel: store });
   const topology = mergedTopology(store);
   const chain = projectTodoChainV1(topology);
-  const layout = layoutTodoGantt(store, chain);
+  const layout = layoutTodoGantt(store, chain, { scope });
   const narrative = await loadNarratives(store, repoRoot);
   const anchorOutcomes = verifyNarrativeAnchors({
     readModel: store,
@@ -673,6 +680,7 @@ export async function renderTodoGanttForProject({
     layout_digest: digestTodoArtifact(layout),
     renderer_version: TODO_GANTT_RENDERER_VERSION,
     project_display_name: identity.displayName,
+    folded_task_count: layout.scope.folded_task_count,
   };
   const rendered = renderTodoGanttHtml({
     readModel: store,
@@ -685,12 +693,14 @@ export async function renderTodoGanttForProject({
   return { store, metadata, memberBindings, rendered };
 }
 
-async function gantt({ repoRoot, outputRef, env }) {
-  const { store, metadata, memberBindings, rendered } = await renderTodoGanttForProject({ repoRoot, env });
+async function gantt({ repoRoot, outputRef, env, scope = DEFAULT_GANTT_SCOPE }) {
+  const { store, metadata, memberBindings, rendered } = await renderTodoGanttForProject({
+    repoRoot, env, scope,
+  });
   await atomicWriteOutput(repoRoot, outputRef, rendered.html);
-  const descriptor = { schema: 'lattice.todo_gantt_artifact.v1', project_id: store.project_id,
+  const descriptor = { schema: 'lattice.todo_gantt_artifact.v2', project_id: store.project_id,
     output_ref: outputRef, manifest_digest: metadata.manifest_digest,
-    renderer_version: TODO_GANTT_RENDERER_VERSION, html_digest: rendered.html_digest,
+    renderer_version: TODO_GANTT_RENDERER_VERSION, scope, html_digest: rendered.html_digest,
     artifact_digest: '' };
   descriptor.artifact_digest = todoSelfDigest(descriptor, 'artifact_digest');
   await atomicWriteOutput(repoRoot, ganttDescriptorRef(outputRef),
@@ -699,6 +709,8 @@ async function gantt({ repoRoot, outputRef, env }) {
     schema: 'lattice.todo_gantt_result.v1',
     project_id: store.project_id,
     output_ref: outputRef,
+    scope,
+    folded_task_count: metadata.folded_task_count,
     manifest_digest: metadata.manifest_digest,
     member_bindings: memberBindings,
     narrative_bindings_digest: metadata.narrative_bindings_digest,
@@ -727,7 +739,7 @@ async function ganttStatus({ repoRoot, outputRef, env }) {
     const result = { schema: 'lattice.todo_gantt_status_result.v1', project_id: store.project_id,
       output_ref: outputRef, descriptor_ref: descriptorRef, artifact_status: 'missing',
       current_manifest_digest: store.manifest.manifest_digest, artifact_manifest_digest: null,
-      html_digest: null, renderer_version: null, result_digest: '' };
+      html_digest: null, renderer_version: null, scope: null, result_digest: '' };
     result.result_digest = todoSelfDigest(result, 'result_digest');
     return result;
   }
@@ -737,7 +749,9 @@ async function ganttStatus({ repoRoot, outputRef, env }) {
     throw new TodoStoreError('GANTT_ARTIFACT_INVALID', 'artifact_digest_mismatch', undefined,
       { output_ref: outputRef, descriptor_ref: descriptorRef });
   }
-  const current = await renderTodoGanttForProject({ repoRoot, env });
+  // Re-render at the artifact's own scope: comparing a `--scope all` artifact
+  // against a default-scope render would report a false `stale`.
+  const current = await renderTodoGanttForProject({ repoRoot, env, scope: descriptor.scope });
   if (descriptor.project_id !== current.store.project_id) {
     throw new TodoStoreError('GANTT_ARTIFACT_INVALID', 'artifact_project_mismatch', undefined,
       { output_ref: outputRef });
@@ -749,12 +763,12 @@ async function ganttStatus({ repoRoot, outputRef, env }) {
     project_id: current.store.project_id, output_ref: outputRef, descriptor_ref: descriptorRef,
     artifact_status: artifactStatus, current_manifest_digest: current.metadata.manifest_digest,
     artifact_manifest_digest: descriptor.manifest_digest, html_digest: descriptor.html_digest,
-    renderer_version: descriptor.renderer_version, result_digest: '' };
+    renderer_version: descriptor.renderer_version, scope: descriptor.scope, result_digest: '' };
   result.result_digest = todoSelfDigest(result, 'result_digest');
   return result;
 }
 
-async function serveGantt({ repoRoot, port, stdout, env }) {
+async function serveGantt({ repoRoot, port, stdout, env, scope = DEFAULT_GANTT_SCOPE }) {
   const initialStore = await readTodoStoreStable({ repoRoot });
   const identity = await resolveProjectIdentity({ repoRoot, projectId: initialStore.project_id, env });
   const live = await startTodoGanttLiveServer({
@@ -763,7 +777,7 @@ async function serveGantt({ repoRoot, port, stdout, env }) {
     port,
     render: async () => {
       const { rendered, metadata } = await renderTodoGanttForProject({
-        repoRoot, stable: true, displayName: identity.displayName,
+        repoRoot, stable: true, displayName: identity.displayName, scope,
       });
       return { html: rendered.html, head_digest: metadata.manifest_digest };
     },
@@ -919,9 +933,15 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     action = (repoRoot) => rebuildSnapshot({ repoRoot, planKey: argv[3] });
   } else if (argv.length === 1 && argv[0] === 'gantt') {
     action = (repoRoot) => gantt({ repoRoot, outputRef: DEFAULT_GANTT_REF, env });
+  } else if (argv.length === 3 && argv[0] === 'gantt' && argv[1] === '--scope'
+    && TODO_GANTT_SCOPES.includes(argv[2])) {
+    action = (repoRoot) => gantt({ repoRoot, outputRef: DEFAULT_GANTT_REF, env, scope: argv[2] });
   } else if (argv.length === 3 && argv[0] === 'gantt' && argv[1] === '--out'
     && isTodoRef(argv[2])) {
     action = (repoRoot) => gantt({ repoRoot, outputRef: argv[2], env });
+  } else if (argv.length === 5 && argv[0] === 'gantt' && argv[1] === '--out'
+    && isTodoRef(argv[2]) && argv[3] === '--scope' && TODO_GANTT_SCOPES.includes(argv[4])) {
+    action = (repoRoot) => gantt({ repoRoot, outputRef: argv[2], env, scope: argv[4] });
   } else if (argv.length === 2 && argv[0] === 'gantt' && argv[1] === 'status') {
     action = (repoRoot) => ganttStatus({ repoRoot, outputRef: DEFAULT_GANTT_REF, env });
   } else if (argv.length === 4 && argv[0] === 'gantt' && argv[1] === 'status'
@@ -931,6 +951,13 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     && argv[2] === '--port' && /^(?:0|[1-9][0-9]{0,4})$/u.test(argv[3])
     && Number(argv[3]) <= 65_535) {
     action = (repoRoot) => serveGantt({ repoRoot, port: Number(argv[3]), stdout, env });
+  } else if (argv.length === 6 && argv[0] === 'gantt' && argv[1] === 'serve'
+    && argv[2] === '--port' && /^(?:0|[1-9][0-9]{0,4})$/u.test(argv[3])
+    && Number(argv[3]) <= 65_535 && argv[4] === '--scope'
+    && TODO_GANTT_SCOPES.includes(argv[5])) {
+    action = (repoRoot) => serveGantt({
+      repoRoot, port: Number(argv[3]), stdout, env, scope: argv[5],
+    });
   } else if (argv.length === 3 && argv[0] === 'migrate' && argv[1] === '--input'
     && isTodoRef(argv[2])) {
     action = (repoRoot) => migrate({ repoRoot, inputRef: argv[2] });

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.v8';
+export const TODO_GANTT_RENDERER_VERSION = 'lattice.todo_gantt_renderer.v9';
 export const TODO_GANTT_PROSE_MAX_BYTES = 8 * 1024 * 1024;
 export const TODO_GANTT_HTML_MAX_BYTES = 24 * 1024 * 1024;
 
@@ -126,7 +126,23 @@ function normalizeSections(readModel, narratives, anchorOutcomes) {
   return { sections: result, proseBytes };
 }
 
-function renderTaskIndex(sections, lookup) {
+/** task node key -> the fold node standing in for it, empty when nothing folded. */
+function foldIndex(layout) {
+  return new Map((layout?.folded ?? []).map((entry) => [refKey(entry.task), refKey(entry.fold)]));
+}
+
+function renderTaskIndexEntry(section, lookup, folds) {
+  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;
+  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()) {
   const plans = [];
   for (const section of sections) {
     let plan = plans.at(-1);
@@ -136,13 +152,15 @@ function renderTaskIndex(sections, lookup) {
     }
     plan.tasks.push(section);
   }
-  return plans.map((plan) => `<section class="task-index-plan"><h2><code>${escapeHtmlText(plan.planKey)}</code></h2><ol class="task-index-list">${plan.tasks.map((section) => {
-    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>` : '';
-    return `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(key)}"><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>`;
-  }).join('')}</ol></section>`).join('');
+  return plans.map((plan) => {
+    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>`;
+    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>`;
+    return `<section class="task-index-plan"><h2><code>${escapeHtmlText(plan.planKey)}</code></h2>${drawnList}${foldedList}</section>`;
+  }).join('');
 }
 
 function presentationLookup(presentation) {
@@ -240,14 +258,19 @@ function renderRightPane(sections, layout, presentation, readModel) {
       : 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>`;
   }).join('');
-  const taskIndex = renderTaskIndex(sections, lookup);
+  const taskIndex = renderTaskIndex(sections, lookup, foldIndex(layout));
   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) {
+function renderDiagramLegend(presentation, layout = null) {
   const categories = (presentation?.lanes ?? []).map((lane) => `<div class="category-entry"><dt><code>${escapeHtmlText(lane.lane)}</code> — ${escapeHtmlText(lane.name)}</dt><dd>${escapeHtmlText(lane.description)}</dd></div>`).join('');
   const categoryDetails = categories === '' ? '' : `<details class="category-legend"><summary>カテゴリ説明</summary><dl>${categories}</dl></details>`;
-  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>${categoryDetails}<p>縦方向は時間ではなく、登録済み依存関係による工程段階です。ready frontierは全件同時dispatchが既定です。未登録の資源・host制約によりsubsetだけを選ぶ場合は理由を記録します。構造上の最長依存鎖は各工程を同じ重みとして数え、実時間・工数・納期を表しません。</p></div>`;
+  const foldedCount = layout?.scope?.folded_task_count ?? 0;
+  const foldChip = foldedCount === 0 ? ''
+    : `<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>`;
+  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>`;
 }
 
 const CSS = `
@@ -310,6 +333,12 @@ 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}
+.task-index-folded>summary{cursor:pointer;padding:6px 0;color:var(--text-secondary);font-weight:600}
 .status-in-progress .node-surface{fill:var(--surface-1);stroke:var(--accent);stroke-width:2}
 .status-in-progress .status-mark{fill:var(--accent)}
 .status-in-progress .status-bar{stroke:var(--accent);stroke-width:2;stroke-linecap:round}
@@ -405,7 +434,7 @@ export function renderTodoGanttHtml({
     metadata,
     presentation,
   });
-  const html = `<!doctype html><html lang="ja"><head><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Lattice — ${escapeHtmlText(displayName)} 依存工程図</title><style>${CSS}</style></head><body data-gantt-root data-view-state="overview"><main class="shell"><section class="gantt-pane" aria-label="${escapeHtmlAttribute(displayName)} 依存工程図"><div class="diagram-toolbar" role="group" aria-label="図のズーム"><strong class="project-heading">${escapeHtmlText(displayName)} 依存工程図</strong><button type="button" data-zoom-action="out" aria-label="縮小">−</button><button type="button" data-zoom-action="reset">等倍</button><button type="button" data-zoom-action="in" aria-label="拡大">＋</button><button type="button" data-zoom-action="fit">全体表示</button><output class="zoom-readout" data-zoom-output aria-live="polite">100%</output><span class="diagram-note">縦=依存段階（時間ではない）</span></div>${renderDiagramLegend(presentation)}<div class="diagram-scroll" data-diagram-scroll tabindex="0" aria-label="縦方向を主にスクロール可能な依存工程図">${svg}</div></section><div class="pane-divider" data-pane-divider aria-hidden="true"></div><aside class="narrative-pane" aria-label="選択工程の詳細と全工程一覧">${rightPane}</aside></main><script type="application/json" id="todo-gantt-data">${staticData}</script><script>${CONTROLLER}</script></body></html>`;
+  const html = `<!doctype html><html lang="ja"><head><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Lattice — ${escapeHtmlText(displayName)} 依存工程図</title><style>${CSS}</style></head><body data-gantt-root data-view-state="overview"><main class="shell"><section class="gantt-pane" aria-label="${escapeHtmlAttribute(displayName)} 依存工程図"><div class="diagram-toolbar" role="group" aria-label="図のズーム"><strong class="project-heading">${escapeHtmlText(displayName)} 依存工程図</strong><button type="button" data-zoom-action="out" aria-label="縮小">−</button><button type="button" data-zoom-action="reset">等倍</button><button type="button" data-zoom-action="in" aria-label="拡大">＋</button><button type="button" data-zoom-action="fit">全体表示</button><output class="zoom-readout" data-zoom-output aria-live="polite">100%</output><span class="diagram-note">縦=依存段階（時間ではない）</span></div>${renderDiagramLegend(presentation, layout)}<div class="diagram-scroll" data-diagram-scroll tabindex="0" aria-label="縦方向を主にスクロール可能な依存工程図">${svg}</div></section><div class="pane-divider" data-pane-divider aria-hidden="true"></div><aside class="narrative-pane" aria-label="選択工程の詳細と全工程一覧">${rightPane}</aside></main><script type="application/json" id="todo-gantt-data">${staticData}</script><script>${CONTROLLER}</script></body></html>`;
   const htmlBytes = Buffer.byteLength(html, 'utf8');
   if (htmlBytes > TODO_GANTT_HTML_MAX_BYTES) {
     throw new TodoGanttRenderError('TODO_SCALE_EXCEEDED', 'todo gantt HTML limit exceeded', {

package/src/todo-gantt-layout.mjs

@@ -1,3 +1,5 @@
+import { TODO_GANTT_SCOPES, projectTodoGanttScope } from './todo-gantt-scope.mjs';
+
 const TASK_LIMIT = 2_000;
 const EDGE_LIMIT = 8_000;
 const SWEEP_ROUNDS = 4;
@@ -370,18 +372,21 @@ function crossingCount(edges, wave, transversePosition) {
   return total;
 }
 
-export function layoutTodoGantt(readModel, chainProjection) {
-  const { nodes, nodesByKey, edges } = normalizeInput(readModel, chainProjection);
-  const { incoming, outgoing, wave } = assignWaves(nodes, nodesByKey, edges);
-  const layers = orderLayers(nodes, wave, incoming, outgoing);
-  const transversePosition = new Map();
-  for (const layer of layers) {
-    for (let index = 0; index < layer.length; index += 1) transversePosition.set(layer[index], index);
+export function layoutTodoGantt(readModel, chainProjection, options = {}) {
+  const scope = options.scope ?? 'live';
+  if (!TODO_GANTT_SCOPES.includes(scope)) {
+    fail('TODO_LAYOUT_INVALID_INPUT', `scope must be one of ${TODO_GANTT_SCOPES.join(', ')}`);
   }
 
+  // Every structural number below is measured on the FULL graph: the dependency
+  // waves, the longest dependency chain and the ready frontier describe the real
+  // plan. Folding first and measuring second would make all three lie.
+  const full = normalizeInput(readModel, chainProjection);
+  const fullWaves = assignWaves(full.nodes, full.nodesByKey, full.edges);
+
   const longestNodeKeys = new Set(chainProjection.longest_chain_node_refs.map((ref, index) => {
     const key = refKey(refOf(ref, `longest_chain_node_refs[${index}]`));
-    if (!nodesByKey.has(key)) fail('TODO_LAYOUT_INVALID_INPUT', 'chain projection references an absent task');
+    if (!full.nodesByKey.has(key)) fail('TODO_LAYOUT_INVALID_INPUT', 'chain projection references an absent task');
     return key;
   }));
   const longestEdgeKeys = new Set(chainProjection.longest_chain_edges.map((edge, index) => {
@@ -389,12 +394,28 @@ export function layoutTodoGantt(readModel, chainProjection) {
     const from = refKey(refOf(edge.from, `longest_chain_edges[${index}].from`));
     const to = refKey(refOf(edge.to, `longest_chain_edges[${index}].to`));
     const key = JSON.stringify([from, to]);
-    if (!edges.some((candidate) => candidate.key === key)) {
+    if (!full.edges.some((candidate) => candidate.key === key)) {
       fail('TODO_LAYOUT_INVALID_INPUT', 'chain projection edge is absent from the read model');
     }
     return key;
   }));
-  const readyKeys = readyTaskKeys(readModel, nodes, nodesByKey, incoming);
+  const readyKeys = readyTaskKeys(readModel, full.nodes, full.nodesByKey, fullWaves.incoming);
+
+  // 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,
+    });
+  const nodes = projected.nodes;
+  const edges = projected.edges;
+  const nodesByKey = new Map(nodes.map((node) => [node.key, node]));
+  const { incoming, outgoing, wave } = assignWaves(nodes, nodesByKey, edges);
+  const layers = orderLayers(nodes, wave, incoming, outgoing);
+  const transversePosition = new Map();
+  for (const layer of layers) {
+    for (let index = 0; index < layer.length; index += 1) transversePosition.set(layer[index], index);
+  }
   const visibleKeys = new Set(nodes.map(({ key }) => key));
   const displayBranches = edges.flatMap((edge, semanticIndex) => {
     const identities = [...edge.joinIdentities.entries()]
@@ -456,10 +477,19 @@ export function layoutTodoGantt(readModel, chainProjection) {
       ref: { ...node.ref }, title: node.title, lane: node.lane, status: node.status,
       wave: wave.get(node.key), row: transversePosition.get(node.key), visible,
       visibility: {
-        longest_dependency_chain: longestNodeKeys.has(node.key),
+        // 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,
         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,
     };
   });
@@ -566,9 +596,11 @@ export function layoutTodoGantt(readModel, chainProjection) {
     for (const [x] of connector.route) routeMaximumX = Math.max(routeMaximumX, x);
   }
 
+  // Counts stay honest: the summary chips report every ToDo in the plan, not
+  // only the ones the narrowed diagram happens to draw.
   const planMap = new Map();
   const laneMap = new Map();
-  for (const node of nodes) {
+  for (const node of full.nodes) {
     if (!planMap.has(node.ref.plan_key)) planMap.set(node.ref.plan_key, 0);
     planMap.set(node.ref.plan_key, planMap.get(node.ref.plan_key) + 1);
     const key = groupKey(node.ref.plan_key, node.lane);
@@ -592,12 +624,34 @@ export function layoutTodoGantt(readModel, chainProjection) {
       plans: [...planMap.entries()].map(([plan_key, task_count]) => ({ plan_key, task_count })),
       lanes: [...laneMap.values()],
     },
+    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: [...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] },
+      })),
     metrics: {
       crossing_count: crossingCount(edges, wave, transversePosition),
       visible_node_count: visibleKeys.size,
       visible_edge_count: projectedEdges.filter(({ visible }) => visible).length,
-      task_count: nodes.length,
-      edge_count: edges.length,
+      task_count: full.nodes.length,
+      edge_count: full.edges.length,
     },
   };
 }