@quolu/lattice 0.13.0 → 0.15.0

package/src/todo-cli.mjs

@@ -37,6 +37,7 @@ import {
   createTodoStoreWriter,
   TodoStoreError,
   readTodoIndependenceArtifact,
+  readTodoSeamProposalArtifact,
   readTodoStore,
   readTodoWitnessSet,
   todoWitnessRef,
@@ -44,6 +45,7 @@ import {
   readTodoStoreStable,
   rebuildTodoSnapshot,
   writeTodoIndependenceArtifact,
+  writeTodoSeamProposalArtifact,
   verifyEffectivePhaseTodoRevisionSources,
   verifyTodoRevisionSources,
 } from './todo-store.mjs';
@@ -59,6 +61,8 @@ import {
 import {
   TODO_INDEPENDENCE_PROJECTION_SCHEMA,
   explainTodoWitnessSet,
+  isTodoIndependenceLegacyMarker,
+  validateTodoIndependence,
   validateTodoIndependenceProjection,
 } from './todo-independence-contracts.mjs';
 import {
@@ -67,7 +71,19 @@ import {
   migrateWitnessSetTaskIds,
   projectIndependenceFrontier,
 } from './todo-independence.mjs';
-import { selectIndependenceGuidance } from './todo-independence-guidance.mjs';
+import {
+  selectIndependenceGuidance,
+  selectSeamProposalGuidance,
+} from './todo-independence-guidance.mjs';
+import {
+  buildSeamProposalQuerySet,
+  collectSeamProposalEvidenceBundle,
+} from './seam-proposal-queries.mjs';
+import {
+  SEAM_PROPOSAL_PROJECTION_SCHEMA,
+  validateSeamProposalProjection,
+} from './seam-proposal-contracts.mjs';
+import { compileSeamProposalArtifact } from './seam-proposal.mjs';
 import {
   parseTodoSourceRef, todoLegacyReconciliationDigest, validatePhaseTodoRevision,
   validateTodoRevision, validateTodoRevisionSet,
@@ -404,7 +420,7 @@ async function startAdvisory({ repoRoot, store, projection, planKey, taskId }) {
   // 記録があるなら鮮度の判定にHEADが要る。ここで読めないのは判定不能であり、
   // 助言なしで通してよい状態ではない。
   const currentBaseSha = currentHeadSha(repoRoot);
-  const changedPaths = artifact.base_sha !== currentBaseSha
+  const changedPaths = artifact.base_sha !== null && artifact.base_sha !== currentBaseSha
     ? changedPathsSince(repoRoot, artifact.base_sha) : null;
   const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
   const projected = projectIndependenceFrontier({
@@ -442,6 +458,7 @@ async function startAdvisory({ repoRoot, store, projection, planKey, taskId }) {
       coverage: projected.coverage,
       taskDeclared: declared,
       taskStale: selfUnknowns.some(({ kind }) => kind === 'record_stale'),
+      contractSuperseded: isTodoIndependenceLegacyMarker(artifact),
       conflictWithActive: conflictsWithActive[0]?.severability ?? null,
       conflictBetweenReady: readyConflict?.severability ?? null,
     }),
@@ -782,7 +799,8 @@ async function independence({ repoRoot, requestedPlanKey }) {
   const active = projectTodoStatus(store).active_set
     .filter((task) => task.plan_key === planKey);
   // HEADが進んでいる時だけdiffを取る。一致していれば宣言境界を見るまでもない。
-  const changedPaths = artifact !== null && artifact.base_sha !== currentBaseSha
+  const changedPaths = artifact !== null && artifact.base_sha !== null
+    && artifact.base_sha !== currentBaseSha
     ? changedPathsSince(repoRoot, artifact.base_sha) : null;
 
   const projected = projectIndependenceFrontier({
@@ -809,6 +827,9 @@ async function independence({ repoRoot, requestedPlanKey }) {
     // planを読みに来た人にも、着手する人と同じ文言を返す（ADR 0130 Decision 1）。
     guidance: selectIndependenceGuidance({
       coverage: projected.coverage,
+      // 旧契約markerはreadyが空でも「対象なし」へ隠さず、superseded guidanceを返す。
+      readyCount: isTodoIndependenceLegacyMarker(artifact) ? null : ready.length,
+      contractSuperseded: isTodoIndependenceLegacyMarker(artifact),
       taskDeclared: projected.frontier.unknown
         .every(({ unknowns }) => !unknowns.some(({ kind }) => kind === 'witness_missing')),
       taskStale: projected.frontier.unknown
@@ -826,6 +847,185 @@ async function independence({ repoRoot, requestedPlanKey }) {
   return result;
 }
 
+async function seamProposalCompile({ repoRoot, planKey }) {
+  requireCleanWorktree(repoRoot);
+  const currentBaseSha = currentHeadSha(repoRoot);
+  const store = await readTodoStore({ repoRoot });
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (!member) {
+    throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, {
+      plan_key: planKey,
+    });
+  }
+  const independenceArtifact = await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+  if (independenceArtifact === null || !validateTodoIndependence(independenceArtifact)) {
+    throw new TodoStoreError(
+      'SEAM_PROPOSAL_COMPILE_UNAVAILABLE',
+      independenceArtifact === null ? 'independence_artifact_absent' : 'independence_artifact_superseded',
+      undefined,
+      { next_action: 'compile_independence' },
+    );
+  }
+  if (independenceArtifact.outcome !== 'compiled') {
+    throw new TodoStoreError('SEAM_PROPOSAL_COMPILE_UNAVAILABLE', 'independence_outcome_not_compiled', undefined, {
+      outcome: independenceArtifact.outcome,
+      next_action: 'recompile_independence',
+    });
+  }
+  if (independenceArtifact.base_sha !== currentBaseSha) {
+    throw new TodoStoreError('SEAM_PROPOSAL_COMPILE_UNAVAILABLE', 'independence_artifact_stale', undefined, {
+      independence_base_sha: independenceArtifact.base_sha,
+      current_base_sha: currentBaseSha,
+      next_action: 'recompile_independence',
+    });
+  }
+  const witnessSet = await readTodoWitnessSet({ repoRoot, planKey });
+  if (witnessSet === null) {
+    throw new TodoStoreError('SEAM_PROPOSAL_COMPILE_UNAVAILABLE', 'witness_set_absent', undefined, {
+      next_action: 'declare_witness_set_then_compile_independence',
+    });
+  }
+  if (witnessSet.witness_set_digest !== independenceArtifact.witness_set_digest) {
+    throw new TodoStoreError('SEAM_PROPOSAL_COMPILE_UNAVAILABLE', 'witness_set_changed', undefined, {
+      next_action: 'recompile_independence',
+    });
+  }
+
+  const { query_set: querySet } = buildSeamProposalQuerySet({
+    conflictResources: independenceArtifact.conflict_resources,
+  });
+  const [sensorEvidence, proposalEvidence] = await Promise.all([
+    collectWitnessSensorEvidence({ cwd: repoRoot, witnessSet }),
+    collectSeamProposalEvidenceBundle({ cwd: repoRoot, querySet }),
+  ]);
+  const artifact = compileSeamProposalArtifact({
+    independenceArtifact,
+    witnessSet,
+    plan: member.plan,
+    compiledAt: new Date().toISOString(),
+    sensorEvidence,
+    evidence: proposalEvidence.evidence,
+    rawCollected: proposalEvidence.raw_collected,
+  });
+  const { ref } = await writeTodoSeamProposalArtifact({ repoRoot, artifact });
+  const verdictCounts = {
+    seam_candidate: artifact.decisions.filter(({ verdict }) => verdict === 'seam_candidate').length,
+    intentional_serial: artifact.decisions
+      .filter(({ verdict }) => verdict === 'intentional_serial').length,
+    unknown_requires_evidence: artifact.decisions
+      .filter(({ verdict }) => verdict === 'unknown_requires_evidence').length,
+  };
+  const result = {
+    schema: 'lattice.seam_proposal_compile_result.v1',
+    project_id: artifact.project_id,
+    plan_key: artifact.plan_key,
+    plan_version: artifact.source_binding.plan_version,
+    base_sha: artifact.source_binding.base_sha,
+    artifact_ref: ref,
+    component_count: artifact.decisions.length,
+    conflict_resource_count: artifact.decisions
+      .reduce((count, decision) => count + decision.conflicts.length, 0),
+    verdict_counts: verdictCounts,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
+}
+
+function summarizeSeamProposalDecision(decision) {
+  return {
+    component_id: decision.component_id,
+    verdict: decision.verdict,
+    task_ids: decision.task_ids,
+    conflicts: decision.conflicts.map(({
+      resource_id: resourceId, kind, target, task_pairs: taskPairs,
+    }) => ({
+      resource_id: resourceId,
+      kind,
+      target,
+      task_pairs: taskPairs,
+    })),
+    proposed_surfaces: decision.seam_candidate?.proposed_surfaces ?? [],
+    affected_tests: decision.seam_candidate?.affected_tests ?? [],
+    limits: decision.seam_candidate?.limits ?? [],
+    reasons: decision.reasons,
+    unknowns: decision.unknowns,
+  };
+}
+
+async function seamProposal({ repoRoot, requestedPlanKey }) {
+  const store = await readTodoStore({ repoRoot });
+  if (requestedPlanKey !== null
+    && !store.members.some(({ descriptor }) => descriptor.plan_key === requestedPlanKey)) {
+    throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, {
+      plan_key: requestedPlanKey,
+    });
+  }
+  const frontier = computeReadyFrontier(store);
+  const readyPlanKeys = [...new Set(frontier.map(({ plan_key: key }) => key))].sort();
+  const candidatePlanKeys = readyPlanKeys.length > 0
+    ? readyPlanKeys
+    : store.members.map(({ descriptor }) => descriptor.plan_key).sort();
+  if (requestedPlanKey === null && candidatePlanKeys.length > 1) {
+    throw new TodoStoreError('SEAM_PROPOSAL_PLAN_AMBIGUOUS', 'plan_selection_ambiguous', undefined, {
+      plan_keys: candidatePlanKeys,
+      ready_plan_keys: readyPlanKeys,
+      next_action: 'rerun_with_plan_flag',
+    });
+  }
+  const planKey = requestedPlanKey ?? candidatePlanKeys[0] ?? null;
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  const currentBaseSha = currentHeadSha(repoRoot);
+  const independenceArtifact = member === undefined
+    ? null : await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+  const artifact = member === undefined
+    ? null : await readTodoSeamProposalArtifact({ repoRoot, store, planKey });
+
+  let coverage = 'verified';
+  if (artifact === null) coverage = 'missing';
+  else {
+    const binding = artifact.source_binding;
+    const independenceMatches = independenceArtifact !== null
+      && validateTodoIndependence(independenceArtifact)
+      && independenceArtifact.schema === binding.independence_schema
+      && independenceArtifact.result_digest === binding.independence_result_digest
+      && independenceArtifact.witness_set_digest === binding.witness_set_digest
+      && independenceArtifact.plan_version === binding.plan_version
+      && independenceArtifact.topology_digest === binding.topology_digest
+      && independenceArtifact.base_sha === binding.base_sha;
+    const planMatches = member !== undefined
+      && member.plan.plan_version === binding.plan_version
+      && member.plan.topology_digest === binding.topology_digest;
+    if (!independenceMatches || !planMatches) coverage = 'superseded';
+    else if (binding.base_sha !== currentBaseSha) coverage = 'stale';
+  }
+
+  const components = artifact?.decisions.map(summarizeSeamProposalDecision) ?? [];
+  const result = {
+    schema: SEAM_PROPOSAL_PROJECTION_SCHEMA,
+    project_id: store.project_id,
+    plan_key: planKey,
+    coverage,
+    compiled_base_sha: artifact?.source_binding.base_sha ?? null,
+    current_base_sha: currentBaseSha,
+    plan_version: artifact?.source_binding.plan_version ?? null,
+    topology_digest: artifact?.source_binding.topology_digest ?? null,
+    independence_result_digest: artifact?.source_binding.independence_result_digest ?? null,
+    compiled_at: artifact?.compiled_at ?? null,
+    guidance: selectSeamProposalGuidance({ coverage }),
+    component_count: artifact === null ? null : components.length,
+    conflict_resource_count: artifact === null ? null : components
+      .reduce((count, component) => count + component.conflicts.length, 0),
+    components,
+    result_digest: '',
+  };
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  if (!validateSeamProposalProjection(result)) {
+    throw new TodoStoreError('SEAM_PROPOSAL_PROJECTION_INVALID', 'seam_proposal_projection_invalid');
+  }
+  return result;
+}
+
 async function readNarrative(repoRoot, ref) {
   const canonicalRoot = await realpath(repoRoot);
   const source = parseTodoSourceRef(ref);
@@ -1007,7 +1207,10 @@ function parseGanttDescriptor(bytes, descriptorRef) {
  * 一つの関数だけが組む。
  */
 export async function ganttLiveHeadDigest({ repoRoot, store }) {
-  const independence = await independenceForGantt({ repoRoot, store });
+  const [independence, seamProposals] = await Promise.all([
+    independenceForGantt({ repoRoot, store }),
+    seamProposalsForGantt({ repoRoot, store }),
+  ]);
   return digestTodoArtifact({
     schema: 'lattice.todo_gantt_live_head.v1',
     manifest_digest: store.manifest.manifest_digest,
@@ -1016,6 +1219,11 @@ export async function ganttLiveHeadDigest({ repoRoot, store }) {
       coverage: entry.coverage,
       frontier_digest: digestTodoArtifact(entry.frontier),
     })),
+    seam_proposals: seamProposals.map((entry) => ({
+      plan_key: entry.plan_key,
+      coverage: entry.coverage,
+      projection_digest: digestTodoArtifact(entry),
+    })),
   });
 }
 
@@ -1030,7 +1238,7 @@ async function independenceForGantt({ repoRoot, store }) {
     if (artifact === null) continue;
     // 記録があるplanが1つでもあれば鮮度の判定にHEADが要る。
     if (currentBaseSha === null) currentBaseSha = currentHeadSha(repoRoot);
-    const changedPaths = artifact.base_sha !== currentBaseSha
+    const changedPaths = artifact.base_sha !== null && artifact.base_sha !== currentBaseSha
       ? changedPathsSince(repoRoot, artifact.base_sha) : null;
     const projected = projectIndependenceFrontier({
       artifact,
@@ -1052,6 +1260,59 @@ async function independenceForGantt({ repoRoot, store }) {
   return projections.length === 0 ? null : projections;
 }
 
+/**
+ * 図が描く全planのseam提案記録を読む。生成は行わず、記録が無いplanもmissing guidanceを
+ * 持つ投影として残すので、「提案対象なし」と「まだ生成していない」を混同しない。
+ */
+async function seamProposalsForGantt({ repoRoot, store }) {
+  let currentBaseSha = null;
+  const projections = [];
+  for (const member of store.members) {
+    const planKey = member.plan.plan_key;
+    const artifact = await readTodoSeamProposalArtifact({ repoRoot, store, planKey });
+    if (artifact === null) {
+      projections.push({
+        project_id: member.plan.project_id,
+        plan_key: planKey,
+        coverage: 'missing',
+        guidance: selectSeamProposalGuidance({ coverage: 'missing' }),
+        component_count: null,
+        conflict_resource_count: null,
+        components: [],
+      });
+      continue;
+    }
+
+    if (currentBaseSha === null) currentBaseSha = currentHeadSha(repoRoot);
+    const independenceArtifact = await readTodoIndependenceArtifact({ repoRoot, store, planKey });
+    const binding = artifact.source_binding;
+    const independenceMatches = independenceArtifact !== null
+      && validateTodoIndependence(independenceArtifact)
+      && independenceArtifact.schema === binding.independence_schema
+      && independenceArtifact.result_digest === binding.independence_result_digest
+      && independenceArtifact.witness_set_digest === binding.witness_set_digest
+      && independenceArtifact.plan_version === binding.plan_version
+      && independenceArtifact.topology_digest === binding.topology_digest
+      && independenceArtifact.base_sha === binding.base_sha;
+    const planMatches = member.plan.plan_version === binding.plan_version
+      && member.plan.topology_digest === binding.topology_digest;
+    const coverage = !independenceMatches || !planMatches ? 'superseded'
+      : binding.base_sha !== currentBaseSha ? 'stale' : 'verified';
+    const components = artifact.decisions.map(summarizeSeamProposalDecision);
+    projections.push({
+      project_id: member.plan.project_id,
+      plan_key: planKey,
+      coverage,
+      guidance: selectSeamProposalGuidance({ coverage }),
+      component_count: components.length,
+      conflict_resource_count: components
+        .reduce((count, component) => count + component.conflicts.length, 0),
+      components,
+    });
+  }
+  return projections;
+}
+
 export async function renderTodoGanttForProject({
   repoRoot, stable = false, displayName = null, env = process.env, readModel = null,
   scope = DEFAULT_GANTT_SCOPE,
@@ -1064,12 +1325,17 @@ export async function renderTodoGanttForProject({
   const presentation = await loadTodoGanttPresentation({ repoRoot, readModel: store });
   const topology = mergedTopology(store);
   const chain = projectTodoChainV1(topology);
-  const independence = await independenceForGantt({ repoRoot, store });
-  const layout = layoutTodoGantt(store, chain, { scope, independence });
+  const [independence, seamProposals] = await Promise.all([
+    independenceForGantt({ repoRoot, store }),
+    seamProposalsForGantt({ repoRoot, store }),
+  ]);
+  const layout = layoutTodoGantt(store, chain, { scope, independence, seamProposals });
   // When the diagram hides history, the page also carries the full diagram so
   // the reader can bring it back in place. Nothing is hidden under `all`.
   const expandedLayout = layout.scope.folded_task_count === 0
-    ? null : layoutTodoGantt(store, chain, { scope: 'all', independence });
+    ? null : layoutTodoGantt(store, chain, {
+      scope: 'all', independence, seamProposals,
+    });
   const narrative = await loadNarratives(store, repoRoot);
   const anchorOutcomes = verifyNarrativeAnchors({
     readModel: store,
@@ -1362,8 +1628,18 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     action = (repoRoot) => independence({ repoRoot, requestedPlanKey: null });
   } else if ((argv.length === 3 || argv.length === 4) && argv[0] === 'independence'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])
-    && (argv.length === 3 || argv[3] === '--json')) {
+  && (argv.length === 3 || argv[3] === '--json')) {
     action = (repoRoot) => independence({ repoRoot, requestedPlanKey: argv[2] });
+  } else if (argv.length === 4 && argv[0] === 'seam-proposal' && argv[1] === 'compile'
+    && argv[2] === '--plan' && isTodoIdentifier(argv[3])) {
+    action = (repoRoot) => seamProposalCompile({ repoRoot, planKey: argv[3] });
+  } else if ((argv.length === 1 && argv[0] === 'seam-proposal')
+    || (argv.length === 2 && argv[0] === 'seam-proposal' && argv[1] === '--json')) {
+    action = (repoRoot) => seamProposal({ repoRoot, requestedPlanKey: null });
+  } else if ((argv.length === 3 || argv.length === 4) && argv[0] === 'seam-proposal'
+    && argv[1] === '--plan' && isTodoIdentifier(argv[2])
+    && (argv.length === 3 || argv[3] === '--json')) {
+    action = (repoRoot) => seamProposal({ repoRoot, requestedPlanKey: argv[2] });
   } else if ((argv.length === 1 && argv[0] === 'verify')
     || (argv.length === 2 && argv[0] === 'verify' && argv[1] === '--json')) {
     action = (repoRoot) => verify({ repoRoot, requestedPlanKey: null });

package/src/todo-gantt-html.mjs

@@ -282,6 +282,54 @@ function renderIndependenceNote(ref, node, summary) {
   return `<p class="readiness-note"><strong>並列可否:</strong> 要直列です。</p><ul class="independence-conflicts">${items}</ul>`;
 }
 
+function renderSeamComponent(component) {
+  const conflicts = component.conflicts.map((conflict) => {
+    const pairs = conflict.task_pairs
+      .map(([left, right]) => `<span class="seam-task-pair"><code>${escapeHtmlText(left)}</code><span aria-hidden="true"> ↔ </span><code>${escapeHtmlText(right)}</code></span>`)
+      .join('');
+    return `<li class="seam-conflict"><strong class="seam-target">${escapeHtmlText(conflict.target)}</strong><span class="seam-conflict-kind"><code>${escapeHtmlText(conflict.kind)}</code></span><span class="seam-pairs">${pairs}</span></li>`;
+  }).join('');
+  const unknowns = component.unknowns.length === 0 ? '' : `<section class="seam-evidence-needed"><h4>次に必要な証拠</h4><ul>${component.unknowns.map((unknown) => {
+    const reference = component.task_ids.includes(unknown.ref)
+      ? `ToDo <code>${escapeHtmlText(unknown.ref)}</code>`
+      : `ref <code>${escapeHtmlText(unknown.ref)}</code>`;
+    return `<li><code>${escapeHtmlText(unknown.kind)}</code><span>${reference}</span></li>`;
+  }).join('')}</ul></section>`;
+  const reasons = component.reasons.length === 0 ? '' : `<section class="seam-reasons"><h4>判定理由</h4><ul>${component.reasons.map((reason) => `<li><code>${escapeHtmlText(reason.code)}</code><span>${escapeHtmlText(reason.detail)}</span></li>`).join('')}</ul></section>`;
+  const proposed = component.proposed_surfaces.length === 0 ? '' : `<section class="seam-surfaces"><h4>提案する所有境界</h4><ul>${component.proposed_surfaces.map((surface) => `<li><strong>${escapeHtmlText(surface.target)}</strong><span><code>${escapeHtmlText(surface.kind)}</code> / <code>${escapeHtmlText(surface.role)}</code> / owner ${surface.owner_task_ids.map((taskId) => `<code>${escapeHtmlText(taskId)}</code>`).join(', ') || '—'}</span></li>`).join('')}</ul></section>`;
+  const affectedTests = component.affected_tests.length === 0 ? ''
+    : `<p class="seam-tests"><strong>影響test:</strong> ${component.affected_tests.map((testRef) => `<code>${escapeHtmlText(testRef)}</code>`).join(', ')}</p>`;
+  return `<article class="seam-component verdict-${escapeHtmlAttribute(component.verdict)}"><header><span>Seam判定</span><code>${escapeHtmlText(component.verdict)}</code></header><ul class="seam-conflicts">${conflicts}</ul>${unknowns}${reasons}${proposed}${affectedTests}</article>`;
+}
+
+function renderSeamPlan(plan, { compact = false } = {}) {
+  const components = plan.components.map(renderSeamComponent).join('');
+  const count = plan.component_count === null ? '—' : String(plan.component_count);
+  const nextAction = plan.guidance.next_action === 'none' ? ''
+    : `<p class="seam-next-action"><strong>次の一歩:</strong> <code>${escapeHtmlText(plan.guidance.next_action)}</code></p>`;
+  return `<section class="seam-plan${compact ? ' seam-plan-compact' : ''}" data-seam-plan="${escapeHtmlAttribute(plan.plan_key)}"><header><code>${escapeHtmlText(plan.plan_key)}</code><span class="seam-coverage coverage-${escapeHtmlAttribute(plan.coverage)}">${escapeHtmlText(plan.guidance.code)}</span><span class="seam-component-count">component ${escapeHtmlText(count)}件</span></header><p class="seam-guidance">${escapeHtmlText(plan.guidance.message)}</p>${nextAction}${components}</section>`;
+}
+
+/**
+ * componentがあるplanを先に展開し、0件planはcoverageごとに畳む。
+ * 実データのunknownと係争資源を、未生成planの列より先に視認できるようにする。
+ */
+function renderSeamProposalOverview(layout) {
+  const plans = layout.seam_proposals?.plans;
+  if (!Array.isArray(plans)) return '';
+  const withComponents = plans.filter((plan) => plan.components.length > 0);
+  const emptyByGuidance = new Map();
+  for (const plan of plans.filter((entry) => entry.components.length === 0)) {
+    if (!emptyByGuidance.has(plan.guidance.code)) emptyByGuidance.set(plan.guidance.code, []);
+    emptyByGuidance.get(plan.guidance.code).push(plan);
+  }
+  const decisions = withComponents.map((plan) => renderSeamPlan(plan)).join('');
+  const emptyGroups = [...emptyByGuidance.entries()].sort(([left], [right]) => compareText(left, right))
+    .map(([code, grouped]) => `<details class="seam-empty-group"><summary><code>${escapeHtmlText(code)}</code><span>${grouped.length} plan</span></summary>${grouped.map((plan) => renderSeamPlan(plan, { compact: true })).join('')}</details>`)
+    .join('');
+  return `<section class="seam-overview"><h2>Seam提案</h2>${decisions}${emptyGroups}</section>`;
+}
+
 function renderRightPane(sections, layout, presentation, readModel) {
   const lookup = presentationLookup(presentation);
   const sectionByKey = new Map(sections.map((section) => [refKey(section.ref), section]));
@@ -323,7 +371,7 @@ function renderRightPane(sections, layout, presentation, readModel) {
   const dispatchSummary = `${readyHeadline}${independenceNote}`;
   const activeLinks = active.length === 0 ? '<p>作業中の工程はありません。</p>'
     : `<ul class="active-list">${active.map((section) => `<li><button type="button" data-select-node-key="${escapeHtmlAttribute(refKey(section.ref))}">${escapeHtmlText(taskReference(section, lookup))} — ${escapeHtmlText(section.task.title)}</button></li>`).join('')}</ul>`;
-  const overview = `<section class="right-overview" data-right-panel="overview"><h1>工程を選択してください</h1><p>左の依存工程図から工程を選ぶと、題名・状態・前提・後続を表示します。</p><div class="status-summary"><span>☐ 未着手 ${counts.pending}</span><span>▶ 作業中 ${counts['in-progress']}</span><span>✅ 完了 ${counts.done}</span><span>⛔ ブロック中 ${counts.blocked}</span></div>${dispatchSummary}${renderPhaseProgress(readModel)}<h2>作業中</h2>${activeLinks}</section>`;
+  const overview = `<section class="right-overview" data-right-panel="overview"><h1>工程を選択してください</h1><p>左の依存工程図から工程を選ぶと、題名・状態・前提・後続を表示します。</p><div class="status-summary"><span>☐ 未着手 ${counts.pending}</span><span>▶ 作業中 ${counts['in-progress']}</span><span>✅ 完了 ${counts.done}</span><span>⛔ ブロック中 ${counts.blocked}</span></div>${dispatchSummary}${renderSeamProposalOverview(layout)}${renderPhaseProgress(readModel)}<h2>作業中</h2>${activeLinks}</section>`;
   const details = sections.map((section) => {
     const key = refKey(section.ref);
     const node = nodeByKey.get(key);
@@ -418,6 +466,17 @@ body{display:grid;grid-template-rows:minmax(0,1fr);height:100vh;margin:0;backgro
 .right-overview h1,.task-detail h1{margin:0 0 16px;font-size:19px;font-weight:650;line-height:1.45}
 .right-overview h2,.task-detail h2{margin:24px 0 8px;font-size:16px;font-weight:600}
 .status-summary{display:flex;flex-wrap:wrap;gap:8px 16px;margin:16px 0;padding:12px;background:var(--surface-2)}
+.seam-overview{margin:24px 0}.seam-overview>h2{margin-bottom:8px}
+.seam-plan{margin:8px 0;padding:12px;border:1px solid var(--border);border-left:4px solid var(--accent);background:var(--surface-2)}
+.seam-plan>header{display:flex;flex-wrap:wrap;align-items:center;gap:6px 10px}.seam-plan>header>code{font-weight:650}.seam-component-count{margin-left:auto;color:var(--text-secondary);font-size:12px}
+.seam-coverage{padding:1px 7px;border:1px solid var(--border);border-radius:9999px;background:var(--surface-1);font-size:11px;font-weight:650}.seam-coverage.coverage-missing,.seam-coverage.coverage-stale,.seam-coverage.coverage-superseded{border-color:var(--critical);color:var(--critical)}
+.seam-guidance,.seam-next-action{margin:6px 0 0;color:var(--text-secondary);font-size:12px}.seam-next-action code{color:var(--text-primary);font-weight:650}
+.seam-component{margin-top:10px;padding:10px;border:1px solid var(--border);border-left:4px solid var(--text-secondary);background:var(--surface-1)}.seam-component.verdict-seam_candidate{border-left-color:var(--good)}.seam-component.verdict-intentional_serial{border-left-color:var(--critical)}.seam-component.verdict-unknown_requires_evidence{border-left-color:var(--accent)}
+.seam-component>header{display:flex;align-items:center;justify-content:space-between;gap:12px;font-size:12px;font-weight:650}.seam-component>header code{overflow-wrap:anywhere}
+.seam-conflicts,.seam-evidence-needed ul,.seam-reasons ul,.seam-surfaces ul{margin:8px 0 0;padding:0;list-style:none}.seam-conflict{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:2px 10px;padding:8px;border:1px solid var(--border)}.seam-conflict+.seam-conflict{margin-top:6px}
+.seam-target{font-size:13.5px;overflow-wrap:anywhere}.seam-conflict-kind{color:var(--text-secondary);font-size:11px}.seam-pairs{grid-column:1 / -1;display:flex;flex-wrap:wrap;gap:4px 10px}.seam-task-pair{font-weight:650}
+.seam-evidence-needed,.seam-reasons,.seam-surfaces{margin-top:10px}.seam-evidence-needed h4,.seam-reasons h4,.seam-surfaces h4{margin:0;font-size:12px}.seam-evidence-needed li,.seam-reasons li,.seam-surfaces li{display:flex;flex-wrap:wrap;justify-content:space-between;gap:4px 12px;padding:5px 8px;background:var(--surface-2)}.seam-evidence-needed li+li,.seam-reasons li+li,.seam-surfaces li+li{margin-top:4px}.seam-evidence-needed li>code{font-weight:650}.seam-evidence-needed li>span,.seam-reasons li>span,.seam-surfaces li>span{color:var(--text-secondary)}
+.seam-tests{margin:8px 0 0;color:var(--text-secondary);font-size:12px}.seam-empty-group{margin-top:8px;border-top:1px solid var(--border)}.seam-empty-group>summary{display:flex;gap:10px;padding:8px 0;cursor:pointer;color:var(--text-secondary)}.seam-empty-group>summary span{margin-left:auto}.seam-plan-compact{border-left-width:1px}
 .phase-overview>p{color:var(--text-secondary)}.phase-overview>ol{display:grid;gap:8px;margin:0;padding:0;list-style:none}.phase-progress{padding:10px 12px;border:1px solid var(--border);border-left-width:4px;background:var(--surface-2)}.phase-progress>header{display:flex;justify-content:space-between;gap:12px}.phase-progress>p{margin:4px 0;color:var(--text-secondary);font-size:12px}.phase-progress progress{display:block;width:100%}.phase-progress.status-accepted{border-left-color:var(--good)}.phase-progress.status-reviewing,.phase-progress.status-gate_ready{border-left-color:var(--accent)}.phase-progress.status-rejected{border-left-color:var(--critical)}
 .active-list,.relation-list{margin:0;padding:0;list-style:none}.active-list li+li,.relation-list li+li{margin-top:8px}
 .active-list button{width:100%}.anchor-status,.readiness-note,.category-description,.relation-empty{color:var(--text-secondary)}

package/src/todo-gantt-layout.mjs

@@ -438,6 +438,79 @@ function normalizeIndependence(value, nodesByKey) {
   return { stateByKey, summary: { plans } };
 }
 
+/**
+ * seam proposalの公開投影を、描画に必要なhuman-facing fieldだけへ畳む。
+ * resource_idは記録のidentityであって表示名ではないため、layoutへ持ち込まない。
+ */
+function normalizeSeamProposals(value) {
+  if (value === null || value === undefined) return { summary: null };
+  if (!Array.isArray(value)) {
+    fail('TODO_LAYOUT_INVALID_INPUT', 'seamProposals must be an array of plan projections');
+  }
+  const plans = value.map((projection) => {
+    if (!plain(projection) || typeof projection.project_id !== 'string'
+      || typeof projection.plan_key !== 'string'
+      || !['missing', 'superseded', 'stale', 'verified'].includes(projection.coverage)
+      || !plain(projection.guidance)
+      || typeof projection.guidance.code !== 'string'
+      || typeof projection.guidance.message !== 'string'
+      || typeof projection.guidance.next_action !== 'string'
+      || !Array.isArray(projection.components)) {
+      fail('TODO_LAYOUT_INVALID_INPUT', 'seam proposal entry has an invalid projection shape');
+    }
+    return {
+      project_id: projection.project_id,
+      plan_key: projection.plan_key,
+      coverage: projection.coverage,
+      guidance: { ...projection.guidance },
+      component_count: projection.component_count,
+      conflict_resource_count: projection.conflict_resource_count,
+      components: projection.components.map((component) => {
+        if (!plain(component) || typeof component.component_id !== 'string'
+          || typeof component.verdict !== 'string'
+          || !Array.isArray(component.task_ids)
+          || !Array.isArray(component.conflicts)
+          || !Array.isArray(component.proposed_surfaces)
+          || !Array.isArray(component.affected_tests)
+          || !Array.isArray(component.limits)
+          || !Array.isArray(component.reasons)
+          || !Array.isArray(component.unknowns)) {
+          fail('TODO_LAYOUT_INVALID_INPUT', 'seam proposal component has an invalid shape');
+        }
+        return {
+          component_id: component.component_id,
+          verdict: component.verdict,
+          task_ids: [...component.task_ids],
+          conflicts: component.conflicts.map((conflict) => {
+            if (!plain(conflict) || typeof conflict.kind !== 'string'
+              || typeof conflict.target !== 'string' || !Array.isArray(conflict.task_pairs)) {
+              fail('TODO_LAYOUT_INVALID_INPUT', 'seam proposal conflict has an invalid shape');
+            }
+            return {
+              kind: conflict.kind,
+              target: conflict.target,
+              task_pairs: conflict.task_pairs.map((pair) => [...pair]),
+            };
+          }),
+          proposed_surfaces: component.proposed_surfaces.map((surface) => ({ ...surface,
+            owner_task_ids: [...surface.owner_task_ids] })),
+          affected_tests: [...component.affected_tests],
+          limits: [...component.limits],
+          reasons: component.reasons.map((reason) => ({ ...reason })),
+          unknowns: component.unknowns.map((unknown) => ({ ...unknown })),
+        };
+      }),
+    };
+  });
+  plans.sort((left, right) => {
+    const leftHasDecisions = left.components.length > 0;
+    const rightHasDecisions = right.components.length > 0;
+    return leftHasDecisions === rightHasDecisions
+      ? compareText(left.plan_key, right.plan_key) : leftHasDecisions ? -1 : 1;
+  });
+  return { summary: { plans } };
+}
+
 export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   const scope = options.scope ?? 'live';
   if (!TODO_GANTT_SCOPES.includes(scope)) {
@@ -467,6 +540,7 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
   }));
   const readyKeys = readyTaskKeys(readModel, full.nodes, full.nodesByKey, fullWaves.incoming);
   const independence = normalizeIndependence(options.independence ?? null, full.nodesByKey);
+  const seamProposals = normalizeSeamProposals(options.seamProposals ?? null);
 
   // Only the geometry stage below sees the narrowed graph.
   const projected = scope === 'all'
@@ -777,6 +851,8 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     nodes: projectedNodes,
     // 図の外が語るための投影。カードはバッジで状態だけを示し、相手と理由は右ペインが持つ。
     independence: independence.summary,
+    // seam提案は図形を増やさず、右ペインで係争資源・ToDo組・判定・不足証拠をまとめて示す。
+    seam_proposals: seamProposals.summary,
     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