@quolu/lattice 0.14.0 → 0.16.0

package/src/todo-independence-contracts.mjs

@@ -13,9 +13,26 @@ import {
 } from './runtime-contracts.mjs';
 import { TODO_INDEPENDENCE_GUIDANCE_CODES } from './todo-independence-guidance.mjs';
 
-export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v1';
-export const TODO_INDEPENDENCE_SCHEMA = 'lattice.todo_independence.v2';
+export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v2';
+/**
+ * まだ受理する旧witness set契約。v1はconcern anchorを持てないだけで、境界宣言としては
+ * v2と同値である。既存宣言を書き換えさせないために読み口を残す。
+ */
+export const TODO_WITNESS_SET_LEGACY_SCHEMAS = Object.freeze(['lattice.todo_witness_set.v1']);
+export const TODO_WITNESS_SET_SCHEMAS = Object.freeze([
+  TODO_WITNESS_SET_SCHEMA,
+  ...TODO_WITNESS_SET_LEGACY_SCHEMAS,
+]);
+
+/** 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_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',
+]);
 
 /** boundary compileが一度に扱えるToDo数（runtime front-endのMAX_COLLECTIONと同じ閉じ方）。 */
 export const TODO_INDEPENDENCE_TASK_LIMIT = 256;
@@ -53,6 +70,19 @@ function plain(value) {
     && Object.getPrototypeOf(value) === Object.prototype;
 }
 
+/**
+ * 既知の旧independence artifactを、単なるschema文字列だけでなく版をまたいで不変な
+ * identity fieldの型までで識別する。本体構造や自己digestは旧契約validatorの再実装に
+ * なるため、ここでは検査しない。
+ */
+export function isTodoIndependenceLegacyArtifactIdentity(value) {
+  return plain(value) && TODO_INDEPENDENCE_LEGACY_SCHEMAS.includes(value.schema)
+    && isTodoIdentifier(value.project_id) && isTodoIdentifier(value.plan_key)
+    && isTodoIdentifier(value.plan_version) && isTodoDigest(value.topology_digest)
+    && isTodoDigest(value.witness_set_digest) && isTodoDigest(value.result_digest)
+    && isGitSha(value.base_sha);
+}
+
 function boundedList(value, validator, limit = TODO_INDEPENDENCE_LIST_LIMIT) {
   return Array.isArray(value) && value.length <= limit && value.every(validator);
 }
@@ -79,6 +109,10 @@ function boundedText(value, maximumBytes = 4_096) {
  * manual witnessとsensor query setの判定正本は`explainRunRequest`だけが持つ（ADR 0123）。
  * ここで同じ規則を書き直すと契約が二箇所へ分裂するため、検証もcompileもこの合成を通す。
  * `requestId`はplan identityとwitness digestから導出され、run lifecycleへは登録されない。
+ *
+ * `concern_anchors`はここで落とす。並列可否の判定はこの合成requestだけを入力にするので、
+ * 落としておけばconcern宣言が判定へ影響しないことが構造で保証される（testの主張ではない）。
+ * 宣言はseam束縛の入力であり、witness setから直接読む。
  */
 export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId }) {
   const taskIds = Object.keys(witnessSet.manual_witness).sort(compareText);
@@ -88,7 +122,10 @@ export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId })
     repo: { base_sha: baseSha, root_kind: 'git' },
     capacity: witnessSet.capacity,
     todos: taskIds.map((taskId) => ({ todo_id: taskId })),
-    manual_witness: witnessSet.manual_witness,
+    manual_witness: Object.fromEntries(taskIds.map((taskId) => {
+      const { concern_anchors: _concernAnchors, ...boundary } = witnessSet.manual_witness[taskId];
+      return [taskId, boundary];
+    })),
     sensor_query_set: witnessSet.sensor_query_set,
     executor_capability: { adapters: ['todo-independence'] },
     claim_mode: RUN_REQUEST_CLAIM_MODE,
@@ -99,10 +136,57 @@ export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId })
 }
 
 /**
- * `lattice.todo_witness_set.v1`を検証し、拒否理由とpathを返す。
+ * 1 taskのconcern anchor宣言を検査する。
+ *
+ * `within`はそのtask自身が`owns`で主張している資源に限る。所有していない資源の内側に
+ * 担当を主張させない。symbol名の実在・資源内包含・task間排他はsensorとcompile側が見る。
+ */
+function explainConcernAnchors(anchors, owns, at) {
+  const reject = (reason, path) => ({ valid: false, reason, path });
+  if (!Array.isArray(anchors) || anchors.length > TODO_CONCERN_ANCHOR_LIMIT) {
+    return reject('bounded_collection_violation', at);
+  }
+  const ownedKeys = new Set(owns.map((own) => `${own.kind}\0${own.target}`));
+  for (const [index, entry] of anchors.entries()) {
+    const entryAt = `${at}/${index}`;
+    if (!exactRecord(entry, ['within', 'symbols'])) {
+      return reject('unexpected_or_missing_keys', entryAt);
+    }
+    if (!exactRecord(entry.within, ['kind', 'target'])
+      || !['symbol', 'path'].includes(entry.within.kind)) {
+      return reject('invalid_concern_anchor_resource', `${entryAt}/within`);
+    }
+    const targetValid = entry.within.kind === 'path'
+      ? repoRelativeResourceTarget(entry.within.target)
+      : boundedText(entry.within.target, 1_024);
+    if (!targetValid) return reject('invalid_concern_anchor_resource', `${entryAt}/within`);
+    if (!ownedKeys.has(`${entry.within.kind}\0${entry.within.target}`)) {
+      return reject('concern_anchor_resource_not_owned', `${entryAt}/within`);
+    }
+    if (!Array.isArray(entry.symbols) || entry.symbols.length < 1
+      || entry.symbols.length > TODO_CONCERN_ANCHOR_LIMIT) {
+      return reject('bounded_collection_violation', `${entryAt}/symbols`);
+    }
+    if (!entry.symbols.every((symbol) => boundedText(symbol, 1_024))) {
+      return reject('invalid_concern_anchor_symbol', `${entryAt}/symbols`);
+    }
+    if (!strictlySorted(entry.symbols)) {
+      return reject('unsorted_or_duplicate_collection', `${entryAt}/symbols`);
+    }
+  }
+  if (!strictlySorted(anchors, (entry) => `${entry.within.kind}\0${entry.within.target}`)) {
+    return reject('unsorted_or_duplicate_collection', at);
+  }
+  return { valid: true };
+}
+
+/**
+ * `lattice.todo_witness_set.v2`（およびconcern anchorを持たない旧v1）を検証し、
+ * 拒否理由とpathを返す。
  *
  * 自分のshapeだけをここで見て、witness本体はprobe requestへ合成して
  * `explainRunRequest`へ委譲する。probeのbase_shaは検証専用の定数であり永続化しない。
+ * `concern_anchors`はprobeから落ちるので、ここだけが判定正本になる。
  */
 export function explainTodoWitnessSet(value) {
   const reject = (reason, at = '') => ({ valid: false, reason, path: at });
@@ -111,7 +195,7 @@ export function explainTodoWitnessSet(value) {
       'schema', 'project_id', 'plan_key', 'capacity', 'sensor_query_set',
       'manual_witness', 'witness_set_digest',
     ])) return reject('unexpected_or_missing_top_level_keys');
-    if (value.schema !== TODO_WITNESS_SET_SCHEMA) return reject('schema_mismatch', '/schema');
+    if (!TODO_WITNESS_SET_SCHEMAS.includes(value.schema)) return reject('schema_mismatch', '/schema');
     if (!isTodoIdentifier(value.project_id)) return reject('invalid_identifier', '/project_id');
     if (!isTodoIdentifier(value.plan_key)) return reject('invalid_identifier', '/plan_key');
     if (!plain(value.manual_witness)) return reject('not_an_object', '/manual_witness');
@@ -128,6 +212,16 @@ export function explainTodoWitnessSet(value) {
     });
     const explained = explainRunRequest(probe);
     if (!explained.valid) return reject(explained.reason, explained.path);
+    // concern anchorはprobeへ写していないので、ここが唯一の判定正本になる。
+    const legacy = TODO_WITNESS_SET_LEGACY_SCHEMAS.includes(value.schema);
+    for (const taskId of taskIds) {
+      const witness = value.manual_witness[taskId];
+      const at = `/manual_witness/${taskId}/concern_anchors`;
+      if (!Object.hasOwn(witness, 'concern_anchors')) continue;
+      if (legacy) return reject('concern_anchors_require_witness_set_v2', at);
+      const anchors = explainConcernAnchors(witness.concern_anchors, witness.owns, at);
+      if (!anchors.valid) return reject(anchors.reason, anchors.path);
+    }
     return { valid: true };
   } catch {
     return reject('non_canonical_witness_set_bytes');
@@ -139,12 +233,39 @@ export function validateTodoWitnessSet(value) {
 }
 
 function conflictEntry(value) {
-  return exactRecord(value, ['task_ids', 'resource_id', 'kind'])
+  return exactRecord(value, ['task_ids', 'resource_id'])
     && Array.isArray(value.task_ids) && value.task_ids.length === 2
     && value.task_ids.every(isTodoIdentifier)
     && compareText(value.task_ids[0], value.task_ids[1]) < 0
-    && boundedText(value.resource_id)
-    && TODO_INDEPENDENCE_CONFLICT_KINDS.includes(value.kind);
+    && boundedText(value.resource_id);
+}
+
+function repoRelativeResourceTarget(value) {
+  if (!boundedText(value) || value.startsWith('/') || value.includes('\\')
+    || /^[A-Za-z]:/u.test(value)) return false;
+  const body = value.endsWith('/') ? value.slice(0, -1) : value;
+  return body.length > 0 && body.split('/')
+    .every((segment) => segment !== '' && segment !== '.' && segment !== '..');
+}
+
+function conflictResourceEntry(value) {
+  if (!exactRecord(value, ['resource_id', 'kind', 'target'])
+    || !boundedText(value.resource_id)
+    || !TODO_INDEPENDENCE_CONFLICT_KINDS.includes(value.kind)) return false;
+  return value.kind === 'path'
+    ? repoRelativeResourceTarget(value.target)
+    : boundedText(value.target);
+}
+
+export function isTodoIndependenceLegacyMarker(value) {
+  return exactRecord(value, [
+    'schema', 'legacy_schema', 'project_id', 'plan_key', 'plan_version',
+    'topology_digest', 'base_sha',
+  ])
+    && value.schema === TODO_INDEPENDENCE_LEGACY_MARKER_SCHEMA
+    && TODO_INDEPENDENCE_LEGACY_SCHEMAS.includes(value.legacy_schema)
+    && isTodoIdentifier(value.project_id) && isTodoIdentifier(value.plan_key)
+    && value.plan_version === null && value.topology_digest === null && value.base_sha === null;
 }
 
 /**
@@ -188,10 +309,10 @@ function wavePlan(value, taskIds) {
 }
 
 /**
- * `lattice.todo_independence.v2`。
+ * `lattice.todo_independence.v3`。
  *
  * conflict／precedence／unknownはnormalized boundary graphから採る（ADR 0127 Decision 4）。
- * conflictはresource kindを併せて持ち、切断可能性の導出を投影側に許す（ADR 0128 Decision 1）。
+ * conflictは`conflict_resources`のresource idを参照し、kindとnormalized targetを一度だけ保持する。
  * `task_boundaries`はtask別の宣言境界で、鮮度のdiff交差判定をartifactだけで閉じるために持つ。
  * `wave_plan`はschedulability compileが`compiled`を返した時だけ持ち、unknownが残る間はnullになる。
  * verdictに現れないペアをverified独立と読めるのは、両taskにunknownが無いときだけである。
@@ -200,7 +321,7 @@ export function validateTodoIndependence(value) {
   try {
     if (!exactRecord(value, [
       'schema', 'project_id', 'plan_key', 'plan_version', 'topology_digest', 'base_sha',
-      'witness_set_digest', 'compiled_at', 'task_ids', 'task_boundaries', 'conflicts',
+      'witness_set_digest', 'compiled_at', 'task_ids', 'task_boundaries', 'conflict_resources', 'conflicts',
       'precedences', 'unknowns', 'wave_plan', 'outcome', 'result_digest',
     ])) return false;
     if (value.schema !== TODO_INDEPENDENCE_SCHEMA) return false;
@@ -221,10 +342,16 @@ export function validateTodoIndependence(value) {
       || !value.task_boundaries.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));
     if (!boundedList(value.conflicts, conflictEntry)
       || !value.conflicts.every((entry) => entry.task_ids.every((taskId) => known.has(taskId)))
+      || !value.conflicts.every((entry) => conflictResourceIds.has(entry.resource_id))
       || !strictlySorted(value.conflicts, (entry) => (
         `${entry.task_ids[0]}\0${entry.task_ids[1]}\0${entry.resource_id}`))) return false;
+    const referencedResourceIds = new Set(value.conflicts.map(({ resource_id: id }) => id));
+    if (referencedResourceIds.size !== value.conflict_resources.length) return false;
     if (!boundedList(value.precedences, precedenceEntry)
       || !value.precedences.every((entry) => known.has(entry.from_task_id) && known.has(entry.to_task_id))
       || !strictlySorted(value.precedences, (entry) => (
@@ -345,7 +472,9 @@ export function validateTodoIndependenceProjection(value) {
     // 記録が無い状態でcompile済みidentityを名乗らない。
     if (value.coverage === 'missing'
       && (value.compiled_base_sha !== null || value.topology_digest !== null)) return false;
-    if (value.coverage !== 'missing' && value.compiled_base_sha === null) return false;
+    if (['verified', 'stale'].includes(value.coverage) && value.compiled_base_sha === null) return false;
+    if (value.coverage === 'superseded' && value.compiled_base_sha === null
+      && (value.plan_version !== null || value.topology_digest !== null)) return false;
     for (const key of ['active_task_ids', 'uncovered_active_task_ids']) {
       if (!Array.isArray(value[key]) || value[key].length > TODO_INDEPENDENCE_TASK_LIMIT
         || !value[key].every(isTodoIdentifier) || !strictlySorted(value[key])) return false;

package/src/todo-independence-guidance.mjs

@@ -12,6 +12,7 @@ export const TODO_INDEPENDENCE_GUIDANCE_CODES = Object.freeze([
   'independence_no_ready_frontier',
   'independence_unrecorded',
   'independence_task_undeclared',
+  'independence_contract_superseded',
   'independence_superseded',
   'independence_stale_for_task',
   'independence_conflict_with_active',
@@ -19,6 +20,13 @@ export const TODO_INDEPENDENCE_GUIDANCE_CODES = Object.freeze([
   'independence_verified',
 ]);
 
+export const SEAM_PROPOSAL_GUIDANCE_CODES = Object.freeze([
+  'seam_proposal_unrecorded',
+  'seam_proposal_superseded',
+  'seam_proposal_stale',
+  'seam_proposal_verified',
+]);
+
 const CATALOG = Object.freeze({
   independence_no_ready_frontier: Object.freeze({
     message: '着手候補が無いため、並列可否を述べる対象が無い。',
@@ -32,6 +40,10 @@ const CATALOG = Object.freeze({
     message: 'この工程はwitness setで宣言されていないため、記録には含まれていない。',
     next_action: 'add_task_to_witness_set_then_compile',
   }),
+  independence_contract_superseded: Object.freeze({
+    message: '記録は旧契約versionで書かれており、現在の並列可否の判定としては読めない。現在の契約での再compileが次の一歩になる。',
+    next_action: 'recompile_independence',
+  }),
   independence_superseded: Object.freeze({
     message: 'planが改訂され、記録は別のtopologyについての判定になっている。',
     next_action: 'migrate_witness_set_then_compile',
@@ -52,6 +64,22 @@ const CATALOG = Object.freeze({
     message: '記録時点の宣言境界では、他のready工程と干渉しない。',
     next_action: 'none',
   }),
+  seam_proposal_unrecorded: Object.freeze({
+    message: 'このplanのseam提案はまだ生成していない。提案対象が無いのではなく、記録が存在しない。',
+    next_action: 'compile_seam_proposal',
+  }),
+  seam_proposal_superseded: Object.freeze({
+    message: '参照元のplanまたは並列可否記録が更新され、このseam提案は現在の競合についての記録ではない。',
+    next_action: 'compile_seam_proposal',
+  }),
+  seam_proposal_stale: Object.freeze({
+    message: 'seam提案の生成後にHEADが進み、記録時点の構造証拠は現在のcodeを指していない。',
+    next_action: 'compile_seam_proposal',
+  }),
+  seam_proposal_verified: Object.freeze({
+    message: 'seam提案の記録は現在のplan、並列可否記録、HEADと一致している。',
+    next_action: 'none',
+  }),
 });
 
 /** 切断可能性の言い換え。conflictの案内へ添える。 */
@@ -82,7 +110,7 @@ export function todoIndependenceGuidance(code, { severability = null } = {}) {
  */
 export function selectIndependenceGuidance({
   coverage, taskDeclared, taskStale, conflictWithActive = null, conflictBetweenReady = null,
-  readyCount = null,
+  contractSuperseded = false, readyCount = null,
 }) {
   // 着手候補が無いなら述べる対象が無い。ここを通さないと、readyが空のとき
   // 「未検査taskが1件も無い」が空虚に真になり、記録が古くても検証済みへ倒れる。
@@ -97,6 +125,9 @@ export function selectIndependenceGuidance({
       severability: conflictBetweenReady,
     });
   }
+  if (contractSuperseded) {
+    return todoIndependenceGuidance('independence_contract_superseded');
+  }
   if (coverage === 'missing') return todoIndependenceGuidance('independence_unrecorded');
   if (coverage === 'superseded') return todoIndependenceGuidance('independence_superseded');
   if (!taskDeclared) return todoIndependenceGuidance('independence_task_undeclared');
@@ -104,6 +135,15 @@ export function selectIndependenceGuidance({
   return todoIndependenceGuidance('independence_verified');
 }
 
+export function selectSeamProposalGuidance({ coverage }) {
+  const code = coverage === 'missing' ? 'seam_proposal_unrecorded'
+    : coverage === 'superseded' ? 'seam_proposal_superseded'
+      : coverage === 'stale' ? 'seam_proposal_stale'
+        : coverage === 'verified' ? 'seam_proposal_verified' : null;
+  if (code === null) throw new TypeError(`unknown seam proposal coverage: ${coverage}`);
+  return todoIndependenceGuidance(code);
+}
+
 /**
  * 宣言からcompileを経て読むまでの順序。helpとMCP instructionsが同じ手順を語るための正本。
  * 面ごとに手順を書き直すと、片方だけが古くなる。

package/src/todo-independence.mjs

@@ -2,6 +2,7 @@ import { digestTodoArtifact, isTodoIdentifier, todoSelfDigest } from './todo-con
 import {
   TODO_INDEPENDENCE_SCHEMA,
   isGitSha,
+  isTodoIndependenceLegacyMarker,
   severabilityOfConflictKind,
   synthesizeWitnessRunRequest,
   validateTodoIndependence,
@@ -50,34 +51,65 @@ export async function collectWitnessSensorEvidence({ cwd, witnessSet, execute =
 }
 
 /**
- * conflictへresource kindを載せる（ADR 0128 Decision 1）。
+ * conflictから参照されるnormalized resourceを正規化してartifactへ載せる。
  *
  * `graph.conflicts`はresource_idしか持たず、宣言由来のstate resource idは任意文字列なので
  * prefixからkindを復元できない。normalized resourceを引けない場合は、切断可能性を
  * 不明のまま記録するのでなくtyped failで止める。
  */
 function conflictsFrom(verdicts, resources) {
-  const kindByResourceId = new Map((Array.isArray(resources) ? resources : [])
-    .map((resource) => [resource?.resource_id, resource?.kind]));
-  return verdicts
+  const resourceById = new Map();
+  for (const resource of Array.isArray(resources) ? resources : []) {
+    const resourceId = resource?.resource_id;
+    if (resourceById.has(resourceId)) {
+      const previous = resourceById.get(resourceId);
+      if (previous.kind !== resource?.kind) {
+        fail('INDEPENDENCE_RESOURCE_KIND_MISMATCH', 'conflict_resource_kind_mismatch', {
+          resource_id: resourceId ?? null,
+          observed_kinds: [previous.kind ?? null, resource?.kind ?? null],
+        });
+      }
+      if (previous.target !== resource?.target) {
+        fail('INDEPENDENCE_RESOURCE_TARGET_MISMATCH', 'conflict_resource_target_mismatch', {
+          resource_id: resourceId ?? null,
+          observed_targets: [previous.target ?? null, resource?.target ?? null],
+        });
+      }
+      fail('INDEPENDENCE_RESOURCE_DUPLICATE', 'conflict_resource_duplicate', {
+        resource_id: resourceId ?? null,
+      });
+    }
+    resourceById.set(resourceId, { kind: resource?.kind, target: resource?.target });
+  }
+  const conflicts = verdicts
     .filter((verdict) => verdict.type === 'conflict')
     .map((verdict) => {
-      const kind = kindByResourceId.get(verdict.resource_id);
+      const resource = resourceById.get(verdict.resource_id);
+      const kind = resource?.kind;
       if (!['symbol', 'path', 'state', 'effect'].includes(kind)) {
         fail('INDEPENDENCE_RESOURCE_KIND_UNRESOLVED', 'conflict_resource_kind_unresolved', {
           resource_id: verdict.resource_id, observed_kind: kind ?? null,
         });
       }
+      if (typeof resource.target !== 'string' || resource.target.length === 0) {
+        fail('INDEPENDENCE_RESOURCE_TARGET_UNRESOLVED', 'conflict_resource_target_unresolved', {
+          resource_id: verdict.resource_id, observed_target: resource.target ?? null,
+        });
+      }
       return {
         task_ids: [...verdict.todo_ids].sort(compareText),
         resource_id: verdict.resource_id,
-        kind,
       };
     })
     .sort((left, right) => compareText(
       `${left.task_ids[0]}\0${left.task_ids[1]}\0${left.resource_id}`,
       `${right.task_ids[0]}\0${right.task_ids[1]}\0${right.resource_id}`,
     ));
+  const used = new Set(conflicts.map(({ resource_id: resourceId }) => resourceId));
+  const conflictResources = [...used]
+    .map((resourceId) => ({ resource_id: resourceId, ...resourceById.get(resourceId) }))
+    .sort((left, right) => compareText(left.resource_id, right.resource_id));
+  return { conflicts, conflictResources };
 }
 
 /**
@@ -141,7 +173,7 @@ function unknownsFrom(detail) {
 }
 
 /**
- * witness setとsensor evidenceから`lattice.todo_independence.v1`を作る。
+ * witness setとsensor evidenceから`lattice.todo_independence.v3`を作る。
  *
  * compileは宣言済みtaskの部分集合へ閉じる（ADR 0127 Decision 4）。未宣言taskを混ぜると、
  * unknownが1件でも出た時点で宣言済みtask同士の判定まで失われるためである。
@@ -187,6 +219,9 @@ export function compileTodoIndependence(options = {}) {
   }
 
   const dispatchable = compiled.outcome === 'dispatchable';
+  const conflictProjection = dispatchable
+    ? conflictsFrom(compiled.pairwise_verdicts, compiled.resources)
+    : { conflicts: [], conflictResources: [] };
   const artifact = {
     schema: TODO_INDEPENDENCE_SCHEMA,
     project_id: plan.project_id,
@@ -201,8 +236,8 @@ export function compileTodoIndependence(options = {}) {
       task_id: taskId,
       paths: boundaryPathsOf(witnessSet.manual_witness[taskId]),
     })),
-    conflicts: dispatchable
-      ? conflictsFrom(compiled.pairwise_verdicts, compiled.resources) : [],
+    conflict_resources: conflictProjection.conflictResources,
+    conflicts: conflictProjection.conflicts,
     precedences: dispatchable ? precedencesFrom(compiled.pairwise_verdicts) : [],
     unknowns: dispatchable ? [] : unknownsFrom(compiled.detail),
     wave_plan: dispatchable
@@ -290,6 +325,24 @@ export function projectIndependenceFrontier({
     };
   }
 
+  if (isTodoIndependenceLegacyMarker(artifact)) {
+    return {
+      coverage: 'superseded',
+      drift: null,
+      active_task_ids: active,
+      uncovered_active_task_ids: active,
+      frontier: {
+        parallel_groups: [],
+        serialize_pairs: [],
+        conflicts_with_active: [],
+        unknown: ready.map((taskId) => ({
+          task_id: taskId,
+          unknowns: [{ kind: 'record_superseded', ref: artifact.legacy_schema }],
+        })),
+      },
+    };
+  }
+
   const superseded = artifact.plan_version !== plan.plan_version
     || artifact.topology_digest !== plan.topology_digest;
   const coverage = superseded ? 'superseded'
@@ -382,9 +435,17 @@ export function projectIndependenceFrontier({
     });
   };
 
+  const conflictResourceById = new Map(artifact.conflict_resources
+    .map((resource) => [resource.resource_id, resource]));
   for (const conflict of artifact.conflicts) {
+    const resource = conflictResourceById.get(conflict.resource_id);
+    if (resource === undefined) {
+      fail('INDEPENDENCE_RESOURCE_KIND_UNRESOLVED', 'conflict_resource_kind_unresolved', {
+        resource_id: conflict.resource_id, observed_kind: null,
+      });
+    }
     notePair(conflict.task_ids[0], conflict.task_ids[1], 'conflict', conflict.resource_id,
-      conflict.kind);
+      resource.kind);
   }
   for (const precedence of artifact.precedences) {
     notePair(precedence.from_task_id, precedence.to_task_id, 'precedence', precedence.reason, null);

package/src/todo-store.mjs

@@ -21,9 +21,12 @@ import {
   validateTodoSnapshot,
 } from './todo-contracts.mjs';
 import {
+  TODO_INDEPENDENCE_LEGACY_MARKER_SCHEMA,
+  isTodoIndependenceLegacyArtifactIdentity,
   validateTodoIndependence,
   validateTodoWitnessSet,
 } from './todo-independence-contracts.mjs';
+import { validateSeamProposal } from './seam-proposal-contracts.mjs';
 import { sha256Bytes, verifyLinearHashChain } from './hash-chain.mjs';
 import {
   parseTodoSourceRef,
@@ -3609,12 +3612,25 @@ export async function readTodoIndependenceArtifact(options = {}) {
   const member = activeMember(store, options.planKey);
   const ref = todoIndependenceRef(member.plan.plan_key, member.plan.plan_version);
   try {
-    return await readArtifact(repoRoot, ref, {
+    const artifact = await readArtifact(repoRoot, ref, {
       code: 'INDEPENDENCE_ARTIFACT_INVALID',
       maxBytes: INDEPENDENCE_ARTIFACT_BYTES,
-      validate: validateTodoIndependence,
+      // 旧契約は本体を信用せず、canonical JSONと版をまたいで不変なidentityの型だけを見る。
+      // schema名だけの壊れた記録や現行v3をこの分岐へ逃がさず、旧版集合も明示したものだけに閉じる。
+      validate: (value) => validateTodoIndependence(value)
+        || isTodoIndependenceLegacyArtifactIdentity(value),
       missing: true,
     });
+    if (artifact === null || validateTodoIndependence(artifact)) return artifact;
+    return {
+      schema: TODO_INDEPENDENCE_LEGACY_MARKER_SCHEMA,
+      legacy_schema: artifact.schema,
+      project_id: member.plan.project_id,
+      plan_key: member.plan.plan_key,
+      plan_version: null,
+      topology_digest: null,
+      base_sha: null,
+    };
   } catch (error) {
     // 読めない記録は握りつぶさない。ただしどのplanをどう直すかまで言わないと、
     // 消費者は「壊れている」以上のことができない。
@@ -3630,6 +3646,91 @@ export async function readTodoIndependenceArtifact(options = {}) {
   }
 }
 
+const SEAM_PROPOSAL_ARTIFACT_NAME = 'seam-proposal.json';
+const SEAM_PROPOSAL_ARTIFACT_BYTES = 4_194_304;
+
+/** independence.jsonと同じplan versionディレクトリへ並置し、manifestへ登録しない。 */
+export function todoSeamProposalRef(planKey, planVersion) {
+  return `${STORE_ROOT_REF}/plans/${planKey}/${planVersion}/${SEAM_PROPOSAL_ARTIFACT_NAME}`;
+}
+
+/**
+ * seam proposal artifactをactive planと現在のindependence artifactへbindして書く。
+ * planの正本とmanifestには触れない。
+ */
+export async function writeTodoSeamProposalArtifact(options = {}) {
+  const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+  const { artifact } = options;
+  if (!validateSeamProposal(artifact)) {
+    fail('SEAM_PROPOSAL_ARTIFACT_INVALID', 'seam_proposal_artifact_invalid');
+  }
+  return withLock(repoRoot, async () => {
+    const store = await readTodoStore({ repoRoot, forWrite: true, now: options.now });
+    if (store.project_id !== artifact.project_id) {
+      fail('SEAM_PROPOSAL_BINDING_MISMATCH', 'project_id_mismatch', {
+        expected: store.project_id, actual: artifact.project_id,
+      });
+    }
+    const member = activeMember(store, artifact.plan_key);
+    const binding = artifact.source_binding;
+    if (member.plan.plan_version !== binding.plan_version) {
+      fail('SEAM_PROPOSAL_BINDING_MISMATCH', 'plan_version_mismatch', {
+        expected: member.plan.plan_version, actual: binding.plan_version,
+      });
+    }
+    if (member.plan.topology_digest !== binding.topology_digest) {
+      fail('SEAM_PROPOSAL_BINDING_MISMATCH', 'topology_digest_mismatch', {
+        expected: member.plan.topology_digest, actual: binding.topology_digest,
+      });
+    }
+    const independenceArtifact = await readTodoIndependenceArtifact({
+      repoRoot, store, planKey: artifact.plan_key,
+    });
+    if (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) {
+      fail('SEAM_PROPOSAL_BINDING_MISMATCH', 'independence_binding_mismatch');
+    }
+    const ref = todoSeamProposalRef(artifact.plan_key, binding.plan_version);
+    await atomicWrite(path.resolve(repoRoot, ref), canonicalLine(artifact));
+    return { ref, artifact };
+  });
+}
+
+/**
+ * active planに並置されたseam proposal artifactを読む。
+ * 無ければnull、壊れた記録はtyped failureとし、missingへ丸めない。
+ */
+export async function readTodoSeamProposalArtifact(options = {}) {
+  const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+  const store = options.store ?? await readTodoStore({ repoRoot, now: options.now });
+  const member = activeMember(store, options.planKey);
+  const ref = todoSeamProposalRef(member.plan.plan_key, member.plan.plan_version);
+  try {
+    return await readArtifact(repoRoot, ref, {
+      code: 'SEAM_PROPOSAL_ARTIFACT_INVALID',
+      maxBytes: SEAM_PROPOSAL_ARTIFACT_BYTES,
+      validate: validateSeamProposal,
+      missing: true,
+    });
+  } catch (error) {
+    if (error instanceof TodoStoreError && error.code === 'SEAM_PROPOSAL_ARTIFACT_INVALID') {
+      throw new TodoStoreError(error.code, error.detail.reason, undefined, {
+        ...error.detail,
+        plan_key: member.plan.plan_key,
+        artifact_ref: ref,
+        next_action: 'recompile_seam_proposal_or_remove_stale_record',
+      });
+    }
+    throw error;
+  }
+}
+
 const WITNESS_SET_BYTES = 4_194_304;
 
 /**