@quolu/lattice 0.50.1 → 0.52.0

package/src/todo-gantt-layout.mjs

@@ -1,4 +1,6 @@
 import { TODO_GANTT_SCOPES, projectTodoGanttScope } from './todo-gantt-scope.mjs';
+import { buildTodoGanttHierarchy } from './todo-gantt-nested.mjs';
+import { projectTodoCrossPlanDependencies } from './todo-store.mjs';
 
 const TASK_LIMIT = 2_000;
 const EDGE_LIMIT = 8_000;
@@ -229,6 +231,9 @@ function normalizeInput(readModel, chainProjection) {
       for (const after of join.after) addEdge(after, join.before, 'join', identity);
     }
   }
+  for (const dependency of projectTodoCrossPlanDependencies(members)) {
+    addEdge(dependency.from, dependency.to, 'cross_plan');
+  }
   if (edgeMap.size > EDGE_LIMIT) {
     fail('TODO_SCALE_EXCEEDED', 'todo gantt edge limit exceeded', {
       task_count: nodesByKey.size, task_limit: TASK_LIMIT,
@@ -521,7 +526,7 @@ function normalizeSeamProposals(value) {
   return { summary: { plans } };
 }
 
-export function layoutTodoGantt(readModel, chainProjection, options = {}) {
+function layoutTodoGanttFlat(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(', ')}`);
@@ -898,3 +903,72 @@ export function layoutTodoGantt(readModel, chainProjection, options = {}) {
     },
   };
 }
+
+function applyHierarchySemantics(level, semanticByKey) {
+  const layout = {
+    ...level.layout,
+    nodes: level.layout.nodes.map((node) => {
+      const semantic = semanticByKey.get(refKey(node.ref));
+      return semantic === undefined ? node : { ...node, visibility: { ...semantic.visibility } };
+    }),
+  };
+  return {
+    layout,
+    children: level.children.map((child) => ({
+      ...child,
+      level: applyHierarchySemantics(child.level, semanticByKey),
+    })),
+  };
+}
+
+function descendantNodes(level) {
+  return level.children.flatMap((child) => [
+    ...child.level.layout.nodes,
+    ...descendantNodes(child.level),
+  ]);
+}
+
+export function layoutTodoGantt(readModel, chainProjection, options = {}) {
+  const fullLayout = layoutTodoGanttFlat(readModel, chainProjection, options);
+  let nested;
+  try {
+    const visibleTaskKeys = (options.scope ?? 'live') === 'all' ? null
+      : new Set(fullLayout.nodes.map((node) => refKey(node.ref)));
+    nested = buildTodoGanttHierarchy(
+      readModel, options, layoutTodoGanttFlat, visibleTaskKeys,
+    );
+  } catch (error) {
+    if (error?.code !== 'TODO_LAYOUT_INVALID_HIERARCHY') throw error;
+    fail(error.code, error.message, error.detail);
+  }
+  if (nested === null) return fullLayout;
+
+  // 階層ごとの縮約graphは座標だけを決める。ready/最長鎖/独立性まで縮約graphで
+  // 再計算すると、未完の子を持つdone親が後続をreadyへ進めるなど、実graphと違う判断を描く。
+  const semanticLayout = options.scope === 'all'
+    ? fullLayout : layoutTodoGanttFlat(readModel, chainProjection, { ...options, scope: 'all' });
+  const semanticByKey = new Map(semanticLayout.nodes.map((node) => [refKey(node.ref), node]));
+  const semanticRoot = applyHierarchySemantics(nested.root, semanticByKey);
+  const rootLayout = semanticRoot.layout;
+  return {
+    ...rootLayout,
+    full_edges: fullLayout.full_edges,
+    groups: fullLayout.groups,
+    scope: fullLayout.scope,
+    folded: fullLayout.folded,
+    hierarchy_nodes: descendantNodes(semanticRoot),
+    metrics: {
+      ...rootLayout.metrics,
+      visible_node_count: nested.metrics.visibleNodeCount,
+      visible_edge_count: nested.metrics.visibleEdgeCount,
+      task_count: fullLayout.metrics.task_count,
+      edge_count: fullLayout.metrics.edge_count,
+    },
+    hierarchy: {
+      schema: 'lattice.todo_gantt_hierarchy.v1',
+      children: semanticRoot.children,
+      maximum_depth: nested.metrics.maximumDepth,
+      task_count: nested.metrics.taskCount,
+    },
+  };
+}

package/src/todo-gantt-nested.mjs

@@ -0,0 +1,263 @@
+import { projectTodoChainV1 } from './todo-chain.mjs';
+import { projectTodoCrossPlanDependencies } from './todo-store.mjs';
+
+const ROOT = Symbol('todo-gantt-root');
+
+function refKey(ref) {
+  return JSON.stringify([ref.project_id, ref.plan_key, ref.task_id]);
+}
+
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function fail(message, detail = null) {
+  const error = new Error(message);
+  error.code = 'TODO_LAYOUT_INVALID_HIERARCHY';
+  error.detail = detail;
+  throw error;
+}
+
+function taskRef(member, taskId) {
+  return {
+    project_id: member.plan.project_id,
+    plan_key: member.plan.plan_key,
+    task_id: taskId,
+  };
+}
+
+function normalizeHierarchy(readModel) {
+  const tasks = new Map();
+  const parentByKey = new Map();
+  const childrenByParent = new Map([[ROOT, []]]);
+  let hasHierarchy = false;
+
+  for (const member of readModel.members) {
+    const ids = new Set(member.plan.tasks.map(({ task_id: taskId }) => taskId));
+    for (const task of member.plan.tasks) {
+      const ref = taskRef(member, task.task_id);
+      const key = refKey(ref);
+      const parentId = task.parent_task_id ?? null;
+      if (parentId !== null && (typeof parentId !== 'string' || !ids.has(parentId))) {
+        fail(`parent_task_id must reference a task in the same plan: ${task.task_id}`, {
+          ref, parent_task_id: parentId,
+        });
+      }
+      const parentKey = parentId === null ? ROOT : refKey(taskRef(member, parentId));
+      tasks.set(key, { ref, task, member });
+      parentByKey.set(key, parentKey);
+      if (!childrenByParent.has(parentKey)) childrenByParent.set(parentKey, []);
+      childrenByParent.get(parentKey).push(key);
+      if (!childrenByParent.has(key)) childrenByParent.set(key, []);
+      hasHierarchy ||= parentId !== null;
+    }
+  }
+  if (!hasHierarchy) return null;
+
+  for (const key of tasks.keys()) {
+    const seen = new Set([key]);
+    let cursor = parentByKey.get(key);
+    while (cursor !== ROOT) {
+      if (seen.has(cursor)) {
+        fail('parent_task_id hierarchy contains a cycle', {
+          task: tasks.get(key).ref,
+          parent: tasks.get(cursor)?.ref ?? null,
+        });
+      }
+      seen.add(cursor);
+      cursor = parentByKey.get(cursor);
+      if (cursor === undefined) fail('parent_task_id hierarchy is disconnected');
+    }
+  }
+  for (const children of childrenByParent.values()) children.sort(compareText);
+  return { tasks, parentByKey, childrenByParent };
+}
+
+function branchUnder(hierarchy, containerKey, taskKey) {
+  let cursor = taskKey;
+  while (cursor !== ROOT) {
+    const parent = hierarchy.parentByKey.get(cursor);
+    if (parent === containerKey) return cursor;
+    cursor = parent;
+  }
+  return null;
+}
+
+function projectRef(hierarchy, containerKey, value) {
+  if (value === null || typeof value !== 'object') return null;
+  const branch = branchUnder(hierarchy, containerKey, refKey(value));
+  return branch === null ? null : { ...hierarchy.tasks.get(branch).ref };
+}
+
+function uniqueRefs(refs) {
+  const byKey = new Map(refs.map((ref) => [refKey(ref), ref]));
+  return [...byKey.values()].sort((left, right) => compareText(refKey(left), refKey(right)));
+}
+
+function projectMember(member, hierarchy, containerKey, selectedKeys) {
+  const tasks = member.plan.tasks.filter((task) => selectedKeys.has(refKey(taskRef(member, task.task_id))));
+  if (tasks.length === 0) return null;
+
+  const hardDependencies = [];
+  const seenHard = new Set();
+  for (const edge of member.plan.hard_dependencies) {
+    const from = projectRef(hierarchy, containerKey, edge.from);
+    const to = projectRef(hierarchy, containerKey, edge.to);
+    if (from === null || to === null || !selectedKeys.has(refKey(from))
+      || !selectedKeys.has(refKey(to)) || refKey(from) === refKey(to)) continue;
+    const key = JSON.stringify([refKey(from), refKey(to)]);
+    if (seenHard.has(key)) continue;
+    seenHard.add(key);
+    hardDependencies.push({ from, to });
+  }
+
+  const joins = [];
+  for (const join of member.plan.joins) {
+    const before = projectRef(hierarchy, containerKey, join.before);
+    if (before === null || !selectedKeys.has(refKey(before))) continue;
+    const after = uniqueRefs(join.after.map((ref) => projectRef(hierarchy, containerKey, ref))
+      .filter((ref) => ref !== null && selectedKeys.has(refKey(ref))
+        && refKey(ref) !== refKey(before)));
+    if (after.length > 0) joins.push({ ...join, after, before });
+  }
+
+  const phaseAcceptDependencies = [];
+  const seenPhaseAccept = new Set();
+  for (const dependency of member.plan.phase_accept_dependencies ?? []) {
+    const to = projectRef(hierarchy, containerKey, dependency.to);
+    if (to === null || !selectedKeys.has(refKey(to))) continue;
+    const key = JSON.stringify([dependency.from, refKey(to)]);
+    if (seenPhaseAccept.has(key)) continue;
+    seenPhaseAccept.add(key);
+    phaseAcceptDependencies.push({ ...dependency, to });
+  }
+
+  // plan-scopedのcross-plan edgeも階層levelのtaskへ射影する。子task同士の接続を
+  // root levelで捨てると、nested表示だけ依存線とwaveが消えるため、hard edgeと同じく
+  // 各endpointをそのlevel直下のbranchへ束縛し直す。
+  const planScopedEvents = (member.plan_scoped?.events ?? []).flatMap((event) => {
+    if (event.kind !== 'cross_plan_dependency') return [event];
+    const from = projectRef(hierarchy, containerKey, event.payload.from);
+    const to = projectRef(hierarchy, containerKey, event.payload.to);
+    if (from === null || to === null || !selectedKeys.has(refKey(from))
+      || !selectedKeys.has(refKey(to)) || refKey(from) === refKey(to)) return [];
+    return [{ ...event, payload: { ...event.payload, from, to } }];
+  });
+
+  return {
+    ...member,
+    plan: {
+      ...member.plan,
+      tasks,
+      hard_dependencies: hardDependencies,
+      joins,
+      phase_accept_dependencies: phaseAcceptDependencies,
+    },
+    ...(member.plan_scoped === undefined ? {} : {
+      plan_scoped: { ...member.plan_scoped, events: planScopedEvents },
+    }),
+    tasks: member.tasks.filter(({ task_id: taskId }) => tasks.some((task) => task.task_id === taskId)),
+  };
+}
+
+function filterIndependence(independence, selectedKeys) {
+  if (!Array.isArray(independence)) return independence;
+  const selectedByPlan = new Map();
+  for (const key of selectedKeys) {
+    const [projectId, planKey, taskId] = JSON.parse(key);
+    selectedByPlan.set(JSON.stringify([projectId, planKey]),
+      new Set([...(selectedByPlan.get(JSON.stringify([projectId, planKey])) ?? []), taskId]));
+  }
+  return independence.flatMap((projection) => {
+    const selected = selectedByPlan.get(JSON.stringify([projection.project_id, projection.plan_key]));
+    if (selected === undefined) return [];
+    const frontier = projection.frontier;
+    return [{
+      ...projection,
+      frontier: {
+        ...frontier,
+        parallel_groups: (frontier.parallel_groups ?? []).map((group) => ({
+          ...group, task_ids: group.task_ids.filter((taskId) => selected.has(taskId)),
+        })).filter((group) => group.task_ids.length > 0),
+        serialize_pairs: (frontier.serialize_pairs ?? [])
+          .filter((pair) => pair.task_ids.every((taskId) => selected.has(taskId))),
+        conflicts_with_active: (frontier.conflicts_with_active ?? []).filter((entry) =>
+          selected.has(entry.ready_task_id) && selected.has(entry.active_task_id)),
+        unknown: (frontier.unknown ?? []).filter((entry) => selected.has(entry.task_id)),
+      },
+    }];
+  });
+}
+
+function topologyOf(readModel) {
+  const crossPlanDependencies = projectTodoCrossPlanDependencies(readModel.members);
+  return {
+    nodes: readModel.members.flatMap((member) => member.plan.tasks
+      .map(({ task_id: taskId }) => taskRef(member, taskId))),
+    hard_edges: [
+      ...readModel.members.flatMap((member) => member.plan.hard_dependencies),
+      ...crossPlanDependencies.map(({ from, to }) => ({ from, to })),
+    ],
+    joins: readModel.members.flatMap((member) => member.plan.joins),
+  };
+}
+
+function buildLevel(readModel, hierarchy, containerKey, options, layoutFlat, includesSubtree) {
+  const selected = (hierarchy.childrenByParent.get(containerKey) ?? []).filter(includesSubtree);
+  const selectedKeys = new Set(selected);
+  const members = readModel.members.map((member) =>
+    projectMember(member, hierarchy, containerKey, selectedKeys)).filter(Boolean);
+  const projectedRead = { ...readModel, members };
+  const levelOptions = {
+    ...options,
+    // live foldingは元のfull graphで一度だけ行い、下で選んだtask集合へ反映済み。
+    // 縮約levelでもう一度foldすると、可視な子を持つdone親containerが消える。
+    scope: 'all',
+    independence: filterIndependence(options.independence ?? null, selectedKeys),
+    seamProposals: containerKey === ROOT ? options.seamProposals ?? null : null,
+  };
+  const layout = layoutFlat(projectedRead, projectTodoChainV1(topologyOf(projectedRead)), levelOptions);
+  const children = selected.flatMap((parentKey) => {
+    if ((hierarchy.childrenByParent.get(parentKey) ?? []).length === 0) return [];
+    const childLevel = buildLevel(
+      readModel, hierarchy, parentKey, options, layoutFlat, includesSubtree,
+    );
+    if (childLevel.layout.nodes.length === 0 && childLevel.children.length === 0) return [];
+    return [{
+      parent_ref: { ...hierarchy.tasks.get(parentKey).ref },
+      level: childLevel,
+    }];
+  });
+  return { layout, children };
+}
+
+function levelMetrics(level, depth = 1) {
+  let taskCount = level.layout.nodes.length;
+  let visibleNodeCount = level.layout.metrics.visible_node_count;
+  let visibleEdgeCount = level.layout.metrics.visible_edge_count;
+  let maximumDepth = depth;
+  for (const child of level.children) {
+    const nested = levelMetrics(child.level, depth + 1);
+    taskCount += nested.taskCount;
+    visibleNodeCount += nested.visibleNodeCount;
+    visibleEdgeCount += nested.visibleEdgeCount;
+    maximumDepth = Math.max(maximumDepth, nested.maximumDepth);
+  }
+  return { taskCount, visibleNodeCount, visibleEdgeCount, maximumDepth };
+}
+
+export function buildTodoGanttHierarchy(readModel, options, layoutFlat, visibleTaskKeys = null) {
+  const hierarchy = normalizeHierarchy(readModel);
+  if (hierarchy === null) return null;
+  const memo = new Map();
+  const includesSubtree = (key) => {
+    if (visibleTaskKeys === null) return true;
+    if (memo.has(key)) return memo.get(key);
+    const included = visibleTaskKeys.has(key)
+      || (hierarchy.childrenByParent.get(key) ?? []).some(includesSubtree);
+    memo.set(key, included);
+    return included;
+  };
+  const root = buildLevel(readModel, hierarchy, ROOT, options, layoutFlat, includesSubtree);
+  return { root, metrics: levelMetrics(root) };
+}

package/src/todo-gantt-svg.mjs

@@ -166,10 +166,8 @@ function renderNode(node, maps) {
   const lane = maps.lanes.get(nodeLaneKey);
   const laneLabel = lane === undefined ? node.lane : `${node.lane}、${lane.name}`;
   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 = `工程 ${node.ref.task_id}`;
+  const spokenReference = `工程${node.ref.task_id}`;
   const readyLabel = node.visibility.next_ready ? '。ready frontierの同時dispatch候補' : '';
   const independenceLabel = independence === null ? '' : `。並列可否は${independence.label}`;
   const identity = `正規ID ${node.ref.plan_key}/${node.ref.task_id}`;
@@ -235,7 +233,7 @@ function renderTodoSummary(layout, maps) {
   return { markup: `<g class="todo-summary" aria-label="カテゴリ別ToDo集計表">${markup.join('')}</g>`, height: 96, width: groupX };
 }
 
-export function renderTodoGanttSvg(layout, options = {}) {
+function renderFlatTodoGanttSvg(layout, options = {}) {
   if (layout === null || typeof layout !== 'object' || layout.schema !== 'lattice.todo_gantt_layout.v2'
     || !Array.isArray(layout.nodes) || !Array.isArray(layout.edges)) {
     throw new TypeError('layout must be lattice.todo_gantt_layout.v2');
@@ -276,3 +274,80 @@ export function renderTodoGanttSvg(layout, options = {}) {
     .map(([x, y]) => `<circle class="join-contact-marker" cx="${x}" cy="${y}" r="3"></circle>`).join('');
   return `<svg class="todo-gantt" data-gantt-svg data-svg-width="${width}" data-svg-height="${height}" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}" role="group" aria-label="Todo依存工程図"><desc>縦方向は登録済み依存関係による工程段階。構造上の最長依存鎖は各工程を同じ重みとして数え、実時間・工数・資源律速を表さない。</desc>${summary.markup}<g class="edge-layer">${shiftedEdges}<g class="connector-layer">${connectors}</g><g class="junction-layer">${junctions}${contactMarkers}</g></g><g class="node-layer">${nodes}</g></svg>`;
 }
+
+function svgDimensions(markup) {
+  const match = markup.match(/data-svg-width="([0-9.]+)" data-svg-height="([0-9.]+)"/u);
+  if (match === null) throw new TypeError('nested todo gantt SVG must expose its dimensions');
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+
+function resizeSvg(markup, width, height) {
+  return markup
+    .replace(/data-svg-width="[0-9.]+" data-svg-height="[0-9.]+"/u,
+      `data-svg-width="${width}" data-svg-height="${height}"`)
+    .replace(/viewBox="0 0 [0-9.]+ [0-9.]+" width="[0-9.]+" height="[0-9.]+"/u,
+      `viewBox="0 0 ${width} ${height}" width="${width}" height="${height}"`);
+}
+
+function childLayoutOf(child) {
+  if (child.level.children.length === 0) return child.level.layout;
+  return {
+    ...child.level.layout,
+    hierarchy: {
+      schema: 'lattice.todo_gantt_hierarchy.v1',
+      children: child.level.children,
+    },
+  };
+}
+
+function renderNestedTodoGanttSvg(layout, options) {
+  let markup = renderFlatTodoGanttSvg(layout, options);
+  const base = svgDimensions(markup);
+  let width = base.width;
+  let height = base.height;
+  const panels = [];
+  const toggles = [];
+  const links = [];
+  const nodeByKey = new Map(layout.nodes.map((node) => [nodeKey(node.ref), node]));
+  let nextPanelY = 96;
+
+  for (const child of layout.hierarchy.children) {
+    const key = nodeKey(child.parent_ref);
+    const parent = nodeByKey.get(key);
+    if (parent?.geometry === null || parent === undefined) continue;
+    const childMarkup = renderTodoGanttSvg(childLayoutOf(child), options);
+    const childSize = svgDimensions(childMarkup);
+    // 開いた内部工程図を基底DAGの上へ重ねない。右側へ専用領域を確保し、親カードから
+    // 直交線で結ぶ。これなら後続taskも、同じ箱の兄弟taskも隠れない。
+    const panelX = base.width + 16;
+    const panelY = Math.max(parent.geometry.y + 96, nextPanelY);
+    const panelWidth = childSize.width + 24;
+    const panelHeight = childSize.height + 44;
+    nextPanelY = panelY + panelHeight + 16;
+    width = Math.max(width, panelX + panelWidth + 16);
+    height = Math.max(height, panelY + panelHeight + 16);
+    const embedded = childMarkup.replace('<svg class="todo-gantt"',
+      `<svg x="${panelX + 12}" y="${panelY + 32}" class="todo-gantt nested-task-diagram"`);
+    const label = `工程 ${child.parent_ref.plan_key}/${child.parent_ref.task_id} の内部工程`;
+    panels.push(`<g class="nested-task-panel" data-nested-panel-for="${escapeSvgAttribute(key)}" hidden aria-label="${escapeSvgAttribute(label)}"><rect class="nested-task-surface" x="${panelX}" y="${panelY}" width="${panelWidth}" height="${panelHeight}" rx="8"></rect><text class="nested-task-label" x="${panelX + 12}" y="${panelY + 22}">${escapeSvgText(label)}</text>${embedded}</g>`);
+    const parentX = parent.geometry.x + parent.geometry.width;
+    const parentY = parent.geometry.y + 96 + parent.geometry.height / 2;
+    const elbowX = panelX - 8;
+    links.push(`<path class="nested-task-link" data-nested-link-for="${escapeSvgAttribute(key)}" hidden d="M ${parentX} ${parentY} H ${elbowX} V ${panelY + 18} H ${panelX}"></path>`);
+    const toggleX = parent.geometry.x + parent.geometry.width - 24;
+    const toggleY = parent.geometry.y + 96 + parent.geometry.height - 18;
+    toggles.push(`<g class="nested-task-toggle" data-nested-toggle-for="${escapeSvgAttribute(key)}" tabindex="0" role="button" aria-expanded="false" aria-label="${escapeSvgAttribute(`${label}を開く`)}"><rect x="${toggleX - 8}" y="${toggleY - 13}" width="28" height="22" rx="4"></rect><text x="${toggleX + 6}" y="${toggleY + 3}" text-anchor="middle">＋</text></g>`);
+  }
+
+  markup = resizeSvg(markup, width, height);
+  return markup.replace('</svg>', `<g class="nested-link-layer">${links.join('')}</g><g class="nested-panel-layer">${panels.join('')}</g><g class="nested-toggle-layer">${toggles.join('')}</g></svg>`);
+}
+
+export function renderTodoGanttSvg(layout, options = {}) {
+  if (layout?.hierarchy === undefined) return renderFlatTodoGanttSvg(layout, options);
+  if (layout.hierarchy?.schema !== 'lattice.todo_gantt_hierarchy.v1'
+    || !Array.isArray(layout.hierarchy.children)) {
+    throw new TypeError('layout hierarchy must be lattice.todo_gantt_hierarchy.v1');
+  }
+  return renderNestedTodoGanttSvg(layout, options);
+}

package/src/todo-independence-contracts.mjs

@@ -9,18 +9,20 @@ import {
 import {
   RUN_REQUEST_CLAIM_MODE,
   RUN_REQUEST_DECLARATIVE_SCHEMA,
+  RUN_REQUEST_PREDICTION_SCHEMA,
   RUN_REQUEST_SCHEMA,
   explainRunRequest,
   selfDigest as runtimeSelfDigest,
 } from './runtime-contracts.mjs';
 import { TODO_INDEPENDENCE_GUIDANCE_CODES } from './todo-independence-guidance.mjs';
 
-export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v4';
+export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v5';
 /**
  * まだ受理する旧witness set契約。v3以前の厳密なcompile意味を変えず、
  * 既存宣言を書き換えさせないために読み口を残す。
  */
 export const TODO_WITNESS_SET_LEGACY_SCHEMAS = Object.freeze([
+  'lattice.todo_witness_set.v4',
   'lattice.todo_witness_set.v3',
   'lattice.todo_witness_set.v2',
   'lattice.todo_witness_set.v1',
@@ -32,19 +34,28 @@ export const TODO_WITNESS_SET_SCHEMAS = Object.freeze([
 /** 宣言できる欄はversionごとに違う。どの版から使えるかを1箇所で持つ。 */
 const CONCERN_ANCHOR_SCHEMAS = Object.freeze([
   TODO_WITNESS_SET_SCHEMA,
+  'lattice.todo_witness_set.v4',
   'lattice.todo_witness_set.v3',
   'lattice.todo_witness_set.v2',
 ]);
-const CREATES_SCHEMAS = Object.freeze([TODO_WITNESS_SET_SCHEMA, 'lattice.todo_witness_set.v3']);
+const CREATES_SCHEMAS = Object.freeze([
+  TODO_WITNESS_SET_SCHEMA, 'lattice.todo_witness_set.v4', 'lattice.todo_witness_set.v3',
+]);
 
 /** 1 taskが宣言できるconcern anchorの資源数と、資源あたりのsymbol数の上限。 */
 export const TODO_CONCERN_ANCHOR_LIMIT = 256;
-export const TODO_INDEPENDENCE_SCHEMA = 'lattice.todo_independence.v3';
+export const TODO_INDEPENDENCE_SCHEMA = 'lattice.todo_independence.v5';
 export const TODO_INDEPENDENCE_PROJECTION_SCHEMA = 'lattice.todo_independence_projection.v2';
 export const TODO_INDEPENDENCE_LEGACY_MARKER_SCHEMA = 'lattice.todo_independence_legacy_marker.v1';
 export const TODO_INDEPENDENCE_LEGACY_SCHEMAS = Object.freeze([
   'lattice.todo_independence.v1',
   'lattice.todo_independence.v2',
+  'lattice.todo_independence.v3',
+  // v4は`scope_expanded`を持つが`first_seen_path_count`/`growth_events`が整数固定だった。
+  // v5でnull（＝subset gapで累計が分からない）を足したので、**同じ版名で形を変えず**版を上げる。
+  // 同名変更は「新readerが旧artifactを読める」後方互換しか満たさず、**旧readerが新artifactを
+  // 読めない前方互換破壊**になる（2026-08-09のP0と同型・suzune [1183] / kanade [1200]）。
+  'lattice.todo_independence.v4',
 ]);
 
 /** boundary compileが一度に扱えるToDo数（runtime front-endのMAX_COLLECTIONと同じ閉じ方）。 */
@@ -56,7 +67,7 @@ export const TODO_INDEPENDENCE_COVERAGE = Object.freeze([
 
 /** conflictを生んだresourceの種別。切断可能性の導出はこの種別だけを根拠にする。 */
 export const TODO_INDEPENDENCE_CONFLICT_KINDS = Object.freeze([
-  'symbol', 'path', 'state', 'effect',
+  'symbol', 'path', 'state', 'effect', 'line',
 ]);
 
 /** 切断可能性。code seamで切れるのはsymbol/path起因のconflictだけ（ADR 0128 Decision 2）。 */
@@ -65,7 +76,7 @@ export const TODO_INDEPENDENCE_SEVERABILITY = Object.freeze(['code_seam', 'seria
 /**
  * conflict kindから切断可能性を導く。
  *
- * 共有state／effectはcode seamでは切断できない（RC1 boundary compilerの分類規則と同一）。
+ * 共有state／effectと意味的なlineはcode seamでは切断できない（RC1 boundary compilerの分類規則と同一）。
  * read×write交差から実体化される`rw-*`はkind=stateなのでserialへ倒れる。seam候補を
  * 見逃す方向にしか外れない保守的な誤りであり、既知の限界として受け入れる。
  */
@@ -96,6 +107,43 @@ export function isTodoIndependenceLegacyArtifactIdentity(value) {
     && isGitSha(value.base_sha);
 }
 
+/**
+ * task別の宣言膨張の記録（v4から）。**判定を持たない——事実だけを置く。**
+ *
+ * 何が膨張の原因か（上流の契約確定に追従したのか、自分の変更の後始末か、元から在った面の
+ * 見落としか、思いつきで盛ったのか）は**機械には区別できない**。区別するのはAIであり、
+ * 装置が言えるのは「増えた」「何が増減した」「何回目か」「合流点か」までである。
+ * ここへ閾値も勧告も置かない（勧告はadvisory側の仕事）。
+ *
+ * `removed_paths`を持つのは、増加だけを見ると「盛った」と「宣言をやり直した」が同じ顔に
+ * なるからである。増減を両方見ないと読み手が誤る。
+ *
+ * `first_seen_path_count`と`growth_events`が**null**なのは「**このtaskの履歴が分からない**」で、
+ * 0とは違う。witnessはwave単位のsubsetで書き出せるので、比較相手のartifactに当該taskが
+ * 居ないことがある——その時に今回を初回と置くと、本当の初回と膨張回数が消える。
+ * 初回（比較相手が無い）は`compared_witness_digest=null`＋数値、
+ * subset入替（比較相手はあるがtaskが居ない）は`compared_witness_digest=digest`＋nullで区別する。
+ */
+function scopeExpansionEntry(value) {
+  return plain(value)
+    && exactRecord(value, [
+      'task_id', 'compared_witness_digest', 'first_seen_path_count', 'path_count',
+      'added_paths', 'removed_paths', 'growth_events', 'gate_shape',
+    ])
+    && isTodoIdentifier(value.task_id)
+    && (value.compared_witness_digest === null || isTodoDigest(value.compared_witness_digest))
+    && (value.first_seen_path_count === null
+      || (Number.isSafeInteger(value.first_seen_path_count) && value.first_seen_path_count >= 0))
+    && Number.isSafeInteger(value.path_count) && value.path_count >= 0
+    && boundedList(value.added_paths, (entry) => typeof entry === 'string' && entry.length > 0)
+    && strictlySorted(value.added_paths)
+    && boundedList(value.removed_paths, (entry) => typeof entry === 'string' && entry.length > 0)
+    && strictlySorted(value.removed_paths)
+    && (value.growth_events === null
+      || (Number.isSafeInteger(value.growth_events) && value.growth_events >= 0))
+    && typeof value.gate_shape === 'boolean';
+}
+
 function boundedList(value, validator, limit = TODO_INDEPENDENCE_LIST_LIMIT) {
   return Array.isArray(value) && value.length <= limit && value.every(validator);
 }
@@ -131,7 +179,10 @@ export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId })
   const taskIds = Object.keys(witnessSet.manual_witness).sort(compareText);
   const request = {
     schema: witnessSet.schema === TODO_WITNESS_SET_SCHEMA
-      ? RUN_REQUEST_SCHEMA : RUN_REQUEST_DECLARATIVE_SCHEMA,
+      ? RUN_REQUEST_SCHEMA
+      : witnessSet.schema === 'lattice.todo_witness_set.v4'
+        ? RUN_REQUEST_PREDICTION_SCHEMA
+        : RUN_REQUEST_DECLARATIVE_SCHEMA,
     request_id: requestId,
     repo: { base_sha: baseSha, root_kind: 'git' },
     capacity: witnessSet.capacity,
@@ -221,6 +272,13 @@ export function explainTodoWitnessSet(value) {
     if (value.witness_set_digest !== todoSelfDigest(value, 'witness_set_digest')) {
       return reject('witness_set_digest_mismatch', '/witness_set_digest');
     }
+    for (const taskId of taskIds) {
+      const witness = value.manual_witness[taskId];
+      if (plain(witness) && Object.hasOwn(witness, 'lines')
+        && value.schema !== TODO_WITNESS_SET_SCHEMA) {
+        return reject('lines_require_witness_set_v5', `/manual_witness/${taskId}/lines`);
+      }
+    }
     const probe = synthesizeWitnessRunRequest(value, {
       baseSha: PROBE_BASE_SHA, requestId: 'witness-set-probe',
     });
@@ -342,7 +400,7 @@ export function validateTodoIndependence(value) {
     if (!exactRecord(value, [
       'schema', 'project_id', 'plan_key', 'plan_version', 'topology_digest', 'base_sha',
       'witness_set_digest', 'compiled_at', 'task_ids', 'task_boundaries', 'conflict_resources', 'conflicts',
-      'precedences', 'unknowns', 'wave_plan', 'outcome', 'result_digest',
+      'precedences', 'unknowns', 'wave_plan', 'scope_expanded', 'outcome', 'result_digest',
     ])) return false;
     if (value.schema !== TODO_INDEPENDENCE_SCHEMA) return false;
     if (!isTodoIdentifier(value.project_id) || !isTodoIdentifier(value.plan_key)
@@ -362,6 +420,14 @@ export function validateTodoIndependence(value) {
       || !value.task_boundaries.every((entry, index) => entry.task_id === value.task_ids[index])) {
       return false;
     }
+    // scope_expandedはtask_idsとちょうど一対一。欠けたtaskがあると「膨張していない」と
+    // 「まだ見ていない」が同じ顔になる。
+    if (!boundedList(value.scope_expanded, scopeExpansionEntry, TODO_INDEPENDENCE_TASK_LIMIT)
+      || value.scope_expanded.length !== value.task_ids.length
+      || !strictlySorted(value.scope_expanded, (entry) => entry.task_id)
+      || !value.scope_expanded.every((entry, index) => entry.task_id === value.task_ids[index])) {
+      return false;
+    }
     if (!boundedList(value.conflict_resources, conflictResourceEntry)
       || !strictlySorted(value.conflict_resources, (entry) => entry.resource_id)) return false;
     const conflictResourceIds = new Set(value.conflict_resources.map(({ resource_id: id }) => id));

package/src/todo-independence-guidance.mjs

@@ -156,7 +156,7 @@ const CATALOG = Object.freeze({
 
 /** 切断可能性の言い換え。conflictの案内へ添える。 */
 const SEVERABILITY_HINT = Object.freeze({
-  code_seam: 'symbol／pathの衝突なので、境界を分けるrefactorで並列化しうる。',
+  code_seam: 'symbol／pathの衝突なので、境界を分けるrefactorで並列化しうる。記録済みの競合からseam-proposal compileを検討できる。',
   serial: '共有stateまたはeffectの衝突なので、分割では切り離せない。',
 });
 
@@ -173,6 +173,35 @@ export function todoIndependenceGuidance(code, { severability = null } = {}) {
   };
 }
 
+/**
+ * 記録済みの宣言膨張を、AIが分割を検討するための助言へ写す。
+ *
+ * 判断はしない。膨張回数が既知かつ1回以上という事実だけを入口にし、gate形なら
+ * 依存の合流点という構造事実を強い材料として添える。subset gapで累計がnullのtaskや
+ * 初回宣言は、回数を主張できないので助言を出さない。
+ */
+export function scopeExpansionRecommendations(scopeExpanded) {
+  if (!Array.isArray(scopeExpanded)) {
+    throw new TypeError('scope_expanded must be an array');
+  }
+  return scopeExpanded
+    .filter((entry) => Number.isSafeInteger(entry?.growth_events)
+      && entry.growth_events > 0)
+    .map((entry) => ({
+      code: 'scope_expanded_consider_split',
+      task_id: entry.task_id,
+      growth_events: entry.growth_events,
+      first_seen_path_count: entry.first_seen_path_count,
+      path_count: entry.path_count,
+      gate_shape: entry.gate_shape,
+      message: `宣言が${entry.growth_events}回膨張している。${entry.gate_shape
+        ? 'このtaskは依存の合流点であり、'
+        : ''}内側にgateのリストが生えているなら、A1..Anと残余A'への分割を検討できる。`,
+      next_action: 'consider_todo_split',
+    }))
+    .sort((left, right) => left.task_id.localeCompare(right.task_id));
+}
+
 /**
  * advisoryや投影の状態から、最も行動を要する案内を1つ選ぶ。
  *