@quolu/lattice 0.12.9 → 0.12.11

package/bin/lattice.mjs

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 
+import { installPipeCloseGuard } from '../src/cli-stdio.mjs';
 import { runRuntimeCli } from '../src/runtime-cli.mjs';
 import { renderCliHelp } from '../src/cli-help.mjs';
 import packageJson from '../package.json' with { type: 'json' };
 
+installPipeCloseGuard();
+
 const args = process.argv.slice(2);
 const help = renderCliHelp(args);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.12.9",
+  "version": "0.12.11",
   "description": "Lattice — phase-aware TODO graph compiler and conflict-aware orchestration runtime",
   "type": "module",
   "license": "MIT",
@@ -54,7 +54,7 @@
     "test": "node scripts/run-product-tests.mjs",
     "test:sensor": "npm --prefix sensor test",
     "precheck": "node --check src/bridge-launch-agent.mjs",
-    "check": "node --check bin/lattice.mjs && node --check bin/lattice-mcp.mjs && node --check bin/lattice-dashboard.mjs && node --check bin/lattice-bridge.mjs && node --check src/bridge-config.mjs && node --check src/bridge-server.mjs && node --check src/bridge-daemon.mjs && node --check src/bridge-cli.mjs && node --check src/project-cli.mjs && node --check src/sensor-cli.mjs && node --check src/sensor-runtime.mjs && node --check src/sensor-adapter.mjs && node --check src/factory-diagnostics.mjs && node --check src/runtime-errors.mjs && node --check src/runtime-contracts.mjs && node --check src/runtime-event-store.mjs && node --check src/hash-chain.mjs && node --check src/dag-chain.mjs && node --check src/todo-contracts.mjs && node --check src/todo-chain.mjs && node --check src/todo-store.mjs && node --check src/todo-migration.mjs && node --check src/todo-revision.mjs && node --check src/todo-status.mjs && node --check src/todo-cli.mjs && node --check src/todo-dashboard-registry.mjs && node --check src/todo-gantt-presentation.mjs && node --check src/todo-gantt-live.mjs && node --check src/bounded-seam.mjs && node --check src/todo-narrative-anchor.mjs && node --check src/todo-markdown-renderer.mjs && node --check src/todo-gantt-svg.mjs && node --check src/todo-gantt-html.mjs && node --check src/runtime-projection.mjs && node --check src/runtime-decision-verifier.mjs && node --check src/runtime-front-end.mjs && node --check src/runtime-cli.mjs && node --check src/rc3-dogfood-scaffold.mjs && node --check src/runtime-engine.mjs && node --check src/runtime-scripted-executor.mjs && node --check src/runtime-diff-observer.mjs && node --check src/runtime-worktree-executor.mjs && node --check src/runtime-hold-recompile.mjs && node --check src/rc3-scripted-campaign.mjs && node --check src/rc3-actual-dogfood.mjs && node --check src/rc4-stage1-dogfood.mjs && node --check research/fixtures/dispatch-record/src/dispatch-record.mjs && node --check test/research-dispatch-record.test.mjs",
+    "check": "node --check bin/lattice.mjs && node --check bin/lattice-mcp.mjs && node --check bin/lattice-dashboard.mjs && node --check bin/lattice-bridge.mjs && node --check src/cli-stdio.mjs && node --check src/todo-gantt-layout.mjs && node --check src/todo-gantt-scope.mjs && node --check src/bridge-config.mjs && node --check src/bridge-server.mjs && node --check src/bridge-daemon.mjs && node --check src/bridge-cli.mjs && node --check src/project-cli.mjs && node --check src/sensor-cli.mjs && node --check src/sensor-runtime.mjs && node --check src/sensor-adapter.mjs && node --check src/factory-diagnostics.mjs && node --check src/runtime-errors.mjs && node --check src/runtime-contracts.mjs && node --check src/runtime-event-store.mjs && node --check src/hash-chain.mjs && node --check src/dag-chain.mjs && node --check src/todo-contracts.mjs && node --check src/todo-chain.mjs && node --check src/todo-store.mjs && node --check src/todo-migration.mjs && node --check src/todo-revision.mjs && node --check src/todo-status.mjs && node --check src/todo-cli.mjs && node --check src/todo-dashboard-registry.mjs && node --check src/todo-gantt-presentation.mjs && node --check src/todo-gantt-live.mjs && node --check src/bounded-seam.mjs && node --check src/todo-narrative-anchor.mjs && node --check src/todo-markdown-renderer.mjs && node --check src/todo-gantt-svg.mjs && node --check src/todo-gantt-html.mjs && node --check src/runtime-projection.mjs && node --check src/runtime-decision-verifier.mjs && node --check src/runtime-front-end.mjs && node --check src/runtime-cli.mjs && node --check src/rc3-dogfood-scaffold.mjs && node --check src/runtime-engine.mjs && node --check src/runtime-scripted-executor.mjs && node --check src/runtime-diff-observer.mjs && node --check src/runtime-worktree-executor.mjs && node --check src/runtime-hold-recompile.mjs && node --check src/rc3-scripted-campaign.mjs && node --check src/rc3-actual-dogfood.mjs && node --check src/rc4-stage1-dogfood.mjs && node --check research/fixtures/dispatch-record/src/dispatch-record.mjs && node --check test/research-dispatch-record.test.mjs",
     "check:project-identity": "node --check src/project-identity.mjs",
     "ci": "npm run test && npm run test:sensor && npm run check && npm run check:project-identity"
   }

package/src/cli-help.mjs

@@ -45,9 +45,9 @@ Read commands:
   status [--json]
   verify [--plan <key>] [--json]
   snapshot --rebuild --plan <key>
-  gantt [--out <file>]
+  gantt [--out <file>] [--scope live|all]  # 既定live: 完走した枝を畳む
   gantt status [--out <file>]
-  gantt serve --port <port>  # /projects/<project_id>/ をforeground配信
+  gantt serve --port <port> [--scope live|all]  # /projects/<project_id>/ をforeground配信
   phase status --plan <key>
 
 Write commands:
@@ -106,7 +106,7 @@ const SUBCOMMAND_USAGE = Object.freeze({
   'todo status': 'todo status [--json]',
   'todo verify': 'todo verify [--plan <key>] [--json]',
   'todo snapshot': 'todo snapshot --rebuild --plan <key>',
-  'todo gantt': 'todo gantt [--out <file>] | status [--out <file>] | serve --port <port>',
+  'todo gantt': 'todo gantt [--out <file>] [--scope live|all] | status [--out <file>] | serve --port <port> [--scope live|all]',
   'todo phase': 'todo phase <status|review|accept|reject|reopen> --plan <key> [options]',
   'todo phase status': 'todo phase status --plan <key>',
   'todo phase review': 'todo phase review --plan <key> --phase <id> --reason <text>',

package/src/cli-stdio.mjs

@@ -0,0 +1,40 @@
+/**
+ * CLI stdio guards.
+ *
+ * Reading part of a result is a legitimate use: `lattice todo status --json |
+ * head` stops the consumer as soon as it has what it wants. When that consumer
+ * exits, the next write to stdout raises EPIPE, and Node's default handling
+ * turns it into an unhandled 'error' event — the CLI dies with a stack trace
+ * and a non-zero exit, so a working pipeline reports a failure that never
+ * happened.
+ *
+ * EPIPE from a closed consumer is the POSIX contract, not a fault, so the
+ * process stops quietly. This is deliberately narrow: only EPIPE, only on the
+ * output streams. Every other stream error keeps its previous behaviour and
+ * still crashes the CLI, because those are real faults.
+ */
+
+/**
+ * @param {object} [options]
+ * @param {Array<NodeJS.WriteStream>} [options.streams] streams to guard.
+ * @param {(code: number) => void} [options.exit] process exit, injectable for tests.
+ * @returns {() => void} removes the guards again (used by tests).
+ */
+export function installPipeCloseGuard({
+  streams = [process.stdout, process.stderr],
+  exit = (code) => process.exit(code),
+} = {}) {
+  const installed = [];
+  for (const stream of streams) {
+    if (stream === undefined || stream === null || typeof stream.on !== 'function') continue;
+    const onError = (error) => {
+      if (error?.code !== 'EPIPE') throw error;
+      exit(0);
+    };
+    stream.on('error', onError);
+    installed.push(() => stream.off('error', onError));
+  }
+  return () => {
+    for (const remove of installed) remove();
+  };
+}

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,
     },
   };
 }

package/src/todo-gantt-scope.mjs

@@ -0,0 +1,296 @@
+/**
+ * Todo Gantt scope projection.
+ *
+ * The store carries every completed ToDo forward across plan revisions on
+ * purpose — an accepted artifact is the predecessor of the work that follows
+ * it. That makes the dependency diagram grow monotonically: once a campaign
+ * finishes, its whole tree stays on screen forever and every later revision
+ * stacks on top of it. The journal is the source of truth, so nothing is
+ * 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.
+ *
+ * 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.
+ */
+
+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.
+ */
+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
+ * is at Infinity.
+ *
+ * Edges always increase the wave (`assignWaves` is a longest-path layering), so
+ * visiting nodes in descending wave order guarantees every successor is settled
+ * before the node that depends on it.
+ */
+function distanceToLive(nodes, edges, wave) {
+  const outgoing = new Map(nodes.map(({ key }) => [key, []]));
+  for (const edge of edges) outgoing.get(edge.from).push(edge.to);
+  const distance = new Map();
+  const ordered = [...nodes].sort((left, right) => wave.get(right.key) - wave.get(left.key)
+    || compareText(right.key, left.key));
+  for (const node of ordered) {
+    if (node.status !== 'done') {
+      distance.set(node.key, 0);
+      continue;
+    }
+    let best = Infinity;
+    for (const successor of outgoing.get(node.key)) {
+      const settled = distance.get(successor);
+      if (settled !== undefined && settled + 1 < best) best = settled + 1;
+    }
+    distance.set(node.key, best);
+  }
+  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.
+ *
+ * @returns {{nodes: Array, edges: Array, foldedByKey: Map, folds: Array, refined: boolean}}
+ */
+export function projectTodoGanttScope({
+  nodes, edges, wave, longestChainKeys = new Set(), 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 };
+}

package/src/todo-gantt-svg.mjs

@@ -140,28 +140,39 @@ 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 = TODO_GANTT_STATUS_PRESENTATION[node.status] ?? { mark: '?', label: '状態不明' };
+  const status = fold === null
+    ? TODO_GANTT_STATUS_PRESENTATION[node.status] ?? { mark: '?', label: '状態不明' }
+    : { mark: '▣', label: '完走済み（畳み込み）' };
   const lane = maps.lanes.get(nodeLaneKey);
-  const laneLabel = lane === undefined ? node.lane : `${node.lane}、${lane.name}`;
+  const laneLabel = fold === null
+    ? (lane === undefined ? node.lane : `${node.lane}、${lane.name}`)
+    : fold.lanes.join('、');
   const taskNumber = maps.taskNumbers.get(key);
-  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 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 readyLabel = node.visibility.next_ready ? '。ready frontierの同時dispatch候補' : '';
-  const ariaLabel = `${spokenReference}。${status.label}。${laneLabel}。${node.title}。正規ID ${node.ref.plan_key}/${node.ref.task_id}${readyLabel}`;
+  const identity = fold === null
+    ? `正規ID ${node.ref.plan_key}/${node.ref.task_id}`
+    : `${node.ref.plan_key}の完走済み${fold.task_count}工程をまとめたノード。全件を描くには --scope all`;
+  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>` : '';
   const titleLines = wrapLabel(node.title);
   const titleMarkup = titleLines.map((line, index) => `<tspan x="${x + 10}" dy="${index === 0 ? 0 : 17}" class="node-title-line">${escapeSvgText(line)}</tspan>`).join('');
   const taskNumberAttributes = taskNumber === undefined ? ''
     : ` data-task-number="${escapeSvgAttribute(taskNumber.display_number)}" data-task-number-normalized="${escapeSvgAttribute(taskNumber.normalized_number)}" data-task-number-globally-unique="${taskNumber.globally_unique ? 'true' : 'false'}"`;
-  return `<g class="${classes.join(' ')}" data-node-key="${escapeSvgAttribute(key)}" data-lane-key="${escapeSvgAttribute(nodeLaneKey)}" data-project-id="${escapeSvgAttribute(node.ref.project_id)}" data-plan-key="${escapeSvgAttribute(node.ref.plan_key)}" data-task-id="${escapeSvgAttribute(node.ref.task_id)}"${taskNumberAttributes} tabindex="0" role="button" aria-selected="${node.visibility.selected ? 'true' : 'false'}" aria-label="${escapeSvgAttribute(ariaLabel)}"><rect class="node-surface" x="${x}" y="${y}" width="${width}" height="${height}" rx="4"></rect>${statusBar}<text class="status-mark" x="${x + 10}" y="${y + 21}">${escapeSvgText(status.mark)}</text><text class="node-meta" x="${x + 34}" y="${y + 20}">${escapeSvgText(`${status.label} · ${visibleReference}`)}</text><text class="node-title" x="${x + 10}" y="${y + 42}">${titleMarkup}</text><title>${escapeSvgText(`${spokenReference}: ${node.title} — ${status.label} — ${laneLabel} — 正規ID ${node.ref.plan_key}/${node.ref.task_id}`)}</title></g>`;
+  return `<g class="${classes.join(' ')}" data-node-key="${escapeSvgAttribute(key)}" data-lane-key="${escapeSvgAttribute(nodeLaneKey)}" data-project-id="${escapeSvgAttribute(node.ref.project_id)}" data-plan-key="${escapeSvgAttribute(node.ref.plan_key)}" data-task-id="${escapeSvgAttribute(node.ref.task_id)}"${taskNumberAttributes} tabindex="0" role="button" aria-selected="${node.visibility.selected ? 'true' : 'false'}" aria-label="${escapeSvgAttribute(ariaLabel)}"><rect class="node-surface" x="${x}" y="${y}" width="${width}" height="${height}" rx="4"></rect>${statusBar}<text class="status-mark" x="${x + 10}" y="${y + 21}">${escapeSvgText(status.mark)}</text><text class="node-meta" x="${x + 34}" y="${y + 20}">${escapeSvgText(`${status.label} · ${visibleReference}`)}</text><text class="node-title" x="${x + 10}" y="${y + 42}">${titleMarkup}</text><title>${escapeSvgText(`${spokenReference}: ${node.title} — ${status.label} — ${laneLabel} — ${identity}`)}</title></g>`;
 }
 
 function summaryLabel(value, maximum = 34) {

package/src/todo-store.mjs

@@ -1082,29 +1082,54 @@ function nextEvent(input, storeMember) {
   return event;
 }
 
+/**
+ * The digest replay binds a task's completion to.
+ *
+ * A ToDo completed inside this plan version binds to its own `done` event. A
+ * ToDo carried across a revision has no `done` event in the successor journal —
+ * its completion arrives with the `plan_genesis` state migration, and replay
+ * binds it to the genesis digest (see the carry branch in `replay`). Resolving
+ * only the first case is what made `reopen` unusable on carried work.
+ *
+ * Returns null when the task has no completion to bind to at all.
+ */
+function resolveDoneBindingDigest(storeMember, taskId) {
+  const events = storeMember.journal.events;
+  const authored = [...events].reverse().find((event) => (
+    event.kind === 'done' && event.task_id === taskId
+  ));
+  if (authored !== undefined) return authored.event_digest;
+  const genesis = events[0];
+  if (genesis?.kind !== 'plan_genesis' || !Array.isArray(genesis.state_migration)) return null;
+  const carried = genesis.state_migration.some((migration) => (
+    ['carry', 'carry_reconciled_metadata'].includes(migration.state_policy)
+    && migration.to_task_id === taskId && migration.state?.status === 'done'
+  ));
+  return carried ? genesis.event_digest : null;
+}
+
 function resolveTargetedEvent(input, storeMember) {
   if (input.kind === 'reopen' && exactRecord(input.payload, [
     'reason', 'override_reason',
   ])) {
-    const target = [...storeMember.journal.events].reverse().find((event) => (
-      event.kind === 'done' && event.task_id === input.task_id
-    ));
-    if (target === undefined) fail('STORE_INCONSISTENT', 'invalid_reopen_binding');
+    const targetDigest = resolveDoneBindingDigest(storeMember, input.task_id);
+    if (targetDigest === null) fail('STORE_INCONSISTENT', 'invalid_reopen_binding');
     return {
       ...input,
-      payload: { ...input.payload, target_done_digest: target.event_digest },
+      payload: { ...input.payload, target_done_digest: targetDigest },
     };
   }
   if (input.kind === 'done' && exactRecord(input.payload, [
     'done_mode', 'imported', 'evidence',
   ]) && input.payload.done_mode === 'evidence_promotion' && input.payload.imported === true) {
-    const target = [...storeMember.journal.events].reverse().find((event) => (
-      event.kind === 'done' && event.task_id === input.task_id
-    ));
-    if (target === undefined) fail('STORE_INCONSISTENT', 'invalid_evidence_promotion');
+    // Same binding as `reopen`: an imported completion carried across a revision
+    // is bound to the carrying `plan_genesis`, not to a `done` event. Whether the
+    // completion is actually eligible for promotion stays replay's decision.
+    const targetDigest = resolveDoneBindingDigest(storeMember, input.task_id);
+    if (targetDigest === null) fail('STORE_INCONSISTENT', 'invalid_evidence_promotion');
     return {
       ...input,
-      payload: { ...input.payload, target_done_digest: target.event_digest },
+      payload: { ...input.payload, target_done_digest: targetDigest },
     };
   }
   if (input.kind === 'phase_reopen' && exactRecord(input.payload, ['reason', 'override_reason'])) {