@quolu/lattice 0.78.1 → 0.79.0

package/src/todo-cli.mjs

@@ -1,5 +1,6 @@
 import { cliCommandKind } from './cli-command-kind.mjs';
 import { cliFailureClass } from './cli-failure-class.mjs';
+import { readTaskBackchainContext } from './plan-backchain.mjs';
 import { gitSync } from './git-process.mjs';
 import { createHash } from 'node:crypto';
 import {
@@ -636,7 +637,8 @@ function terminalAuditDoneAdvisory(plan, phases) {
 
 async function mutate({
   repoRoot, env, planKey, taskId, kind, payload, evidenceRef, evidenceMessage = null,
-  advisory = null, noteContext = null, structureContext = null, testResultRef = null,
+  advisory = null, noteContext = null, structureContext = null, featureContext = null,
+  testResultRef = null,
 }) {
   const actor = mutationActor(env);
   const evidence = evidenceRef === null && evidenceMessage === null
@@ -683,7 +685,9 @@ async function mutate({
     throw new TypeError('start mutation requires note context');
   }
   const result = {
-    schema: includesNoteContext ? 'lattice.todo_mutation_result.v5' : 'lattice.todo_mutation_result.v2',
+    schema: includesNoteContext
+      ? featureContext === null ? 'lattice.todo_mutation_result.v5' : 'lattice.todo_mutation_result.v6'
+      : 'lattice.todo_mutation_result.v2',
     project_id: event.project_id,
     plan_key: event.plan_key,
     plan_version: event.plan_version,
@@ -699,6 +703,7 @@ async function mutate({
       design_memo: designMemoProjection(authoredTask),
       note_context: noteContext,
       structure_context: structureContext,
+      ...(featureContext === null ? {} : { feature_context: featureContext }),
     } : {}),
     result_digest: '',
   };
@@ -906,9 +911,12 @@ async function startTask({
   const structureContext = await startStructureContext({
     repoRoot, store, planKey, taskId: resolvedTaskId,
   });
+  const featureContext = await readTaskBackchainContext({
+    repoRoot, plan: member.plan, taskId: resolvedTaskId,
+  });
   return mutate({ repoRoot, env, planKey, taskId: resolvedTaskId, kind: 'start',
     payload: { override_reason: overrideReason }, evidenceRef: null, advisory, noteContext,
-    structureContext });
+    structureContext, featureContext });
 }
 
 // plan改訂でcarryされたin-progress ToDoの再束縛入口（ADR 0191）。task状態・開始時刻は
@@ -916,7 +924,7 @@ async function startTask({
 // literal startだけを束縛に使いcarryを推定しないため、改訂を跨いだ進行中工程の
 // 再開はこの入口だけが正規経路になる。advisory・independence gateは初回startで
 // 済んでいるため再適用しない。
-async function rebindStart({ repoRoot, env, planKey, taskId, reason }) {
+export async function rebindStart({ repoRoot, env, planKey, taskId, reason }) {
   const store = await readTodoStore({ repoRoot });
   const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
   if (member === undefined) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active');
@@ -1816,8 +1824,11 @@ async function todoDetail({ repoRoot, planKey, taskId }) {
   const { context } = await readTodoNoteContext({
     repoRoot, store, planKey, taskId: task.task_id,
   });
+  const featureContext = await readTaskBackchainContext({
+    repoRoot, plan: member.plan, taskId: task.task_id,
+  });
   const result = {
-    schema: 'lattice.todo_detail_result.v3',
+    schema: featureContext === null ? 'lattice.todo_detail_result.v3' : 'lattice.todo_detail_result.v4',
     project_id: store.project_id,
     plan_key: planKey,
     plan_version: member.plan.plan_version,
@@ -1825,6 +1836,7 @@ async function todoDetail({ repoRoot, planKey, taskId }) {
     design_memo: designMemoProjection(task),
     state,
     note_context: context,
+    ...(featureContext === null ? {} : { feature_context: featureContext }),
     result_digest: '',
   };
   result.result_digest = todoSelfDigest(result, 'result_digest');
@@ -3658,6 +3670,7 @@ async function verify({ repoRoot, requestedPlanKey }) {
         case 'lattice.phase_todo_revision.v1':
         case 'lattice.phase_todo_revision.v2':
         case 'lattice.phase_todo_revision.v3':
+        case 'lattice.phase_todo_revision.v4':
           verifiedSourceInventories.set(member.descriptor.plan_key,
             await verifyEffectivePhaseTodoRevisionSources({ repoRoot, member }));
           break;
@@ -3670,7 +3683,7 @@ async function verify({ repoRoot, requestedPlanKey }) {
     const reconciled = member.revision !== null;
     const sourceInventory = verifiedSourceInventories.get(member.descriptor.plan_key) ?? null;
     const phaseRevision = ['lattice.phase_todo_revision.v1', 'lattice.phase_todo_revision.v2',
-      'lattice.phase_todo_revision.v3']
+      'lattice.phase_todo_revision.v3', 'lattice.phase_todo_revision.v4']
       .includes(member.revision?.schema);
     return {
       plan_key: member.descriptor.plan_key,

package/src/todo-revision.mjs

@@ -23,6 +23,7 @@ const PHASE_REVISION_V3_KEYS = [
   'runtime_task_migration', 'task_migration', 'phase_migration', 'source_inventory',
   'reconciliation', 'source_cutover_batch', 'revision_digest',
 ];
+const PHASE_REVISION_V4_KEYS = [...PHASE_REVISION_KEYS, 'backchain'];
 
 const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const boundedText = (value) => typeof value === 'string' && value.length > 0
@@ -64,9 +65,11 @@ export function todoRevisionPlanVersion({
 
 export function phaseTodoRevisionPlanVersion({
   projectId, planKey, predecessor, desiredPlan, taskMigration, phaseMigration,
+  featureGraphDigest = null,
 }) {
   const versionDigest = digestTodoArtifact({
-    schema: ['lattice.todo_plan.v5', 'lattice.todo_plan.v7'].includes(desiredPlan.schema)
+    schema: featureGraphDigest !== null ? 'lattice.phase_todo_revision_version.v3'
+      : ['lattice.todo_plan.v5', 'lattice.todo_plan.v7'].includes(desiredPlan.schema)
       ? 'lattice.phase_todo_revision_version.v2' : 'lattice.phase_todo_revision_version.v1', project_id: projectId,
     plan_key: planKey, predecessor, desired_topology: {
       schema: desiredPlan.schema, project_id: desiredPlan.project_id,
@@ -76,6 +79,7 @@ export function phaseTodoRevisionPlanVersion({
       ...(['lattice.todo_plan.v5', 'lattice.todo_plan.v7'].includes(desiredPlan.schema)
         ? { phase_accept_dependencies: desiredPlan.phase_accept_dependencies } : {}),
     }, task_migration: taskMigration, phase_migration: phaseMigration,
+    ...(featureGraphDigest === null ? {} : { feature_graph_digest: featureGraphDigest }),
   });
   return `rev-${versionDigest.slice(0, 24)}`;
 }
@@ -291,22 +295,51 @@ export function validatePhaseTodoRevision(value) {
     const revisionV1 = value?.schema === 'lattice.phase_todo_revision.v1';
     const revisionV2 = value?.schema === 'lattice.phase_todo_revision.v2';
     const revisionV3 = value?.schema === 'lattice.phase_todo_revision.v3';
-    const keys = revisionV3 ? PHASE_REVISION_V3_KEYS : PHASE_REVISION_KEYS;
-    if (!exactRecord(value, keys) || (!revisionV1 && !revisionV2 && !revisionV3)) return false;
+    const revisionV4 = value?.schema === 'lattice.phase_todo_revision.v4';
+    const keys = revisionV3 ? PHASE_REVISION_V3_KEYS
+      : revisionV4 ? PHASE_REVISION_V4_KEYS : PHASE_REVISION_KEYS;
+    if (!exactRecord(value, keys) || (!revisionV1 && !revisionV2 && !revisionV3 && !revisionV4)) return false;
     if (!isTodoIdentifier(value.project_id) || !isTodoIdentifier(value.plan_key)) return false;
     if (!validPredecessor(value.predecessor) || !validateTodoPlan(value.desired_plan)
       || !(revisionV3
         ? ['lattice.todo_plan.v5', 'lattice.todo_plan.v7'].includes(value.desired_plan.schema)
-        : value.desired_plan.schema === (revisionV2 ? 'lattice.todo_plan.v5' : 'lattice.todo_plan.v4'))
+        : value.desired_plan.schema === (revisionV2 ? 'lattice.todo_plan.v5'
+          : revisionV4 ? 'lattice.todo_plan.v7' : 'lattice.todo_plan.v4'))
       || value.desired_plan.project_id !== value.project_id
       || value.desired_plan.plan_key !== value.plan_key
       || value.desired_plan.predecessor_plan_digest !== value.predecessor.plan_digest
       || !validTaskMigration(value.task_migration)
       || !validPhaseMigration(value.phase_migration, value.desired_plan)) return false;
+    const backchainKeys = [
+      'schema', 'authoring_ref', 'project_id', 'plan_key', 'plan_version',
+      'goal', 'features', 'tasks', 'chain_digest',
+    ];
+    if (revisionV4 && (!(exactRecord(value.backchain, backchainKeys)
+      || exactRecord(value.backchain, [...backchainKeys, 'continuity']))
+      || value.backchain.schema !== 'lattice.plan_backchain.v1'
+      || value.backchain.project_id !== value.project_id
+      || value.backchain.plan_key !== value.plan_key
+      || value.backchain.plan_version !== value.desired_plan.plan_version
+      || (value.backchain.continuity !== undefined
+        && (!Array.isArray(value.backchain.continuity)
+          || value.backchain.continuity.length > 512
+          || !value.backchain.continuity.every((entry) => exactRecord(entry,
+            ['task_id', 'policy', 'reason']) && isTodoIdentifier(entry.task_id)
+            && ['carry', 'reset', 'retire'].includes(entry.policy)
+            && typeof entry.reason === 'string' && entry.reason.trim().length > 0)
+          || new Set(value.backchain.continuity.map(({ task_id: id }) => id)).size
+            !== value.backchain.continuity.length))
+      || value.backchain.chain_digest !== todoSelfDigest(value.backchain, 'chain_digest')
+      || canonicalizeForCompare(value.backchain.tasks.map(({ task_id: id }) => id))
+        !== canonicalizeForCompare(value.desired_plan.tasks.map(({ task_id: id }) => id)))) return false;
     if (value.desired_plan.plan_version !== phaseTodoRevisionPlanVersion({
         projectId: value.project_id, planKey: value.plan_key, predecessor: value.predecessor,
         desiredPlan: value.desired_plan, taskMigration: value.task_migration,
         phaseMigration: value.phase_migration,
+        ...(revisionV4 ? { featureGraphDigest: digestTodoArtifact({
+          goal: value.backchain.goal, features: value.backchain.features,
+          tasks: value.backchain.tasks,
+        }) } : {}),
       })) return false;
     if (revisionV3) {
       if (!validRuntimeTaskMigration(value.runtime_task_migration)
@@ -810,8 +843,10 @@ export function explainPhaseTodoRevision(value) {
     const revisionV1 = value.schema === 'lattice.phase_todo_revision.v1';
     const revisionV2 = value.schema === 'lattice.phase_todo_revision.v2';
     const revisionV3 = value.schema === 'lattice.phase_todo_revision.v3';
-    if (!revisionV1 && !revisionV2 && !revisionV3) return reject('schema_mismatch', '/schema');
-    const keyCheck = explainKeys(value, revisionV3 ? PHASE_REVISION_V3_KEYS : PHASE_REVISION_KEYS, '');
+    const revisionV4 = value.schema === 'lattice.phase_todo_revision.v4';
+    if (!revisionV1 && !revisionV2 && !revisionV3 && !revisionV4) return reject('schema_mismatch', '/schema');
+    const keyCheck = explainKeys(value, revisionV3 ? PHASE_REVISION_V3_KEYS
+      : revisionV4 ? PHASE_REVISION_V4_KEYS : PHASE_REVISION_KEYS, '');
     if (!keyCheck.valid) return keyCheck;
     if (!isTodoIdentifier(value.project_id)) return reject('invalid_identifier', '/project_id');
     if (!isTodoIdentifier(value.plan_key)) return reject('invalid_identifier', '/plan_key');
@@ -819,7 +854,8 @@ export function explainPhaseTodoRevision(value) {
     if (!predecessorCheck.valid) return predecessorCheck;
     if (!validateTodoPlan(value.desired_plan)) return reject('desired_plan_invalid', '/desired_plan');
     const expectedPlanSchemas = revisionV3 ? ['lattice.todo_plan.v5', 'lattice.todo_plan.v7']
-      : [revisionV2 ? 'lattice.todo_plan.v5' : 'lattice.todo_plan.v4'];
+      : [revisionV2 ? 'lattice.todo_plan.v5'
+        : revisionV4 ? 'lattice.todo_plan.v7' : 'lattice.todo_plan.v4'];
     if (!expectedPlanSchemas.includes(value.desired_plan.schema)) {
       return reject('desired_plan_schema_mismatch', '/desired_plan/schema');
     }
@@ -840,6 +876,10 @@ export function explainPhaseTodoRevision(value) {
       projectId: value.project_id, planKey: value.plan_key, predecessor: value.predecessor,
       desiredPlan: value.desired_plan, taskMigration: value.task_migration,
       phaseMigration: value.phase_migration,
+      ...(revisionV4 ? { featureGraphDigest: digestTodoArtifact({
+        goal: value.backchain.goal, features: value.backchain.features,
+        tasks: value.backchain.tasks,
+      }) } : {}),
     });
     if (value.desired_plan.plan_version !== expectedPlanVersion) {
       return reject('plan_version_mismatch', '/desired_plan/plan_version');

package/src/todo-store.mjs

@@ -69,7 +69,7 @@ const TODO_REVISION_SCHEMAS = Object.freeze([
 ]);
 const PHASE_TODO_REVISION_SCHEMAS = Object.freeze([
   'lattice.phase_todo_revision.v1', 'lattice.phase_todo_revision.v2',
-  'lattice.phase_todo_revision.v3',
+  'lattice.phase_todo_revision.v3', 'lattice.phase_todo_revision.v4',
 ]);
 
 export class TodoStoreError extends Error {
@@ -2207,6 +2207,26 @@ export function buildTodoPlan(input) {
   return plan;
 }
 
+function boundPlanBackchain(plan, chain) {
+  if (chain === null || chain === undefined) return null;
+  if (chain.schema !== 'lattice.plan_backchain.v1'
+    || chain.project_id !== plan.project_id || chain.plan_key !== plan.plan_key
+    || chain.plan_version !== plan.plan_version
+    || !isTodoDigest(chain.chain_digest)
+    || chain.chain_digest !== todoSelfDigest(chain, 'chain_digest')) {
+    fail('STORE_INCONSISTENT', 'backchain_plan_binding_invalid');
+  }
+  const binding = {
+    schema: 'lattice.plan_backchain_binding.v1',
+    plan_digest: plan.plan_digest, chain, binding_digest: '',
+  };
+  binding.binding_digest = todoSelfDigest(binding, 'binding_digest');
+  if (Buffer.byteLength(JSON.stringify(binding), 'utf8') > TODO_LIMITS.snapshotBytes) {
+    fail('STORE_WRITE_REFUSED', 'backchain_binding_too_large');
+  }
+  return binding;
+}
+
 export function buildPlanGenesis(plan, input) {
   const event = {
     schema: isPhaseTodoPlanSchema(plan.schema)
@@ -2347,6 +2367,7 @@ async function bootstrapImportedPlan(repoRoot, options) {
   }
   const prepared = prepareImportedArtifacts(repoRoot, options, initialization.projectId, []);
   const { plan, genesis, events, snapshot } = prepared;
+  const backchain = boundPlanBackchain(plan, options.featureChain);
   const base = `${STORE_ROOT_REF}/plans/${plan.plan_key}/${plan.plan_version}`;
   const planRef = `${base}/plan.json`;
   const journalRef = `${base}/journal/active.jsonl`;
@@ -2370,6 +2391,7 @@ async function bootstrapImportedPlan(repoRoot, options) {
     await atomicWrite(path.join(stagedBase, 'plan.json'), canonicalLine(plan));
     await atomicWrite(path.join(stagedBase, 'journal', 'active.jsonl'), Buffer.concat(events.map(canonicalLine)));
     await atomicWrite(path.join(stagedBase, 'snapshot.json'), canonicalLine(snapshot));
+    if (backchain !== null) await atomicWrite(path.join(stagedBase, 'backchain.json'), canonicalLine(backchain));
     await atomicWrite(path.join(stage, 'manifest.json'), canonicalLine(manifest));
     await protocolStage(options, 'bootstrap_staged');
 
@@ -2753,6 +2775,7 @@ export async function appendImportedPlan(options = {}) {
       repoRoot, options, store.project_id, store.members.map(({ plan: memberPlan }) => ({ plan: memberPlan })),
     );
     const { plan, genesis, events, snapshot, tasks } = prepared;
+    const backchain = boundPlanBackchain(plan, options.featureChain);
 
     const base = `${STORE_ROOT_REF}/plans/${plan.plan_key}/${plan.plan_version}`;
     const planRef = `${base}/plan.json`;
@@ -2780,6 +2803,7 @@ export async function appendImportedPlan(options = {}) {
     await atomicWrite(stagedPlan, canonicalLine(plan));
     await atomicWrite(stagedJournal, Buffer.concat(events.map(canonicalLine)));
     await atomicWrite(stagedSnapshot, canonicalLine(snapshot));
+    if (backchain !== null) await atomicWrite(path.join(stagedBase, 'backchain.json'), canonicalLine(backchain));
     for (const [index, artifact] of importedCrossPlan.artifacts.entries()) {
       artifact.stagedAbsolute = path.join(transactionAbsolute, 'plan-scoped', `${index}.jsonl`);
       await atomicWrite(artifact.stagedAbsolute, artifact.finalBytes);
@@ -2824,6 +2848,9 @@ export async function appendImportedPlan(options = {}) {
         await rename(stagedPlan, path.resolve(repoRoot, planRef));
         await rename(stagedJournal, path.resolve(repoRoot, journalRef));
         await rename(stagedSnapshot, path.resolve(repoRoot, snapshotRef));
+        if (backchain !== null) {
+          await rename(path.join(stagedBase, 'backchain.json'), path.join(finalBaseAbsolute, 'backchain.json'));
+        }
         await fsyncDirectory(path.dirname(path.resolve(repoRoot, planRef)));
         await fsyncDirectory(path.dirname(path.resolve(repoRoot, journalRef)));
       }
@@ -2911,14 +2938,16 @@ export async function initializeAuthoredTodoStore(options = {}) {
   const optionKeys = [
     'repoRoot', 'writer', 'projectId', 'repositories', 'plan', 'genesis',
   ];
-  if (!(exactRecord(options, optionKeys)
-    || (exactRecord(options, [...optionKeys, 'onProtocolStage'])
+  const allowedOptions = options.featureChain === undefined ? optionKeys : [...optionKeys, 'featureChain'];
+  if (!(exactRecord(options, allowedOptions)
+    || (exactRecord(options, [...allowedOptions, 'onProtocolStage'])
       && typeof options.onProtocolStage === 'function'))
     || options.projectId !== options.plan?.project_id
     || options.plan?.predecessor_plan_digest !== null) {
     throw new TypeError('authored store initialization input invalid');
   }
   const plan = buildTodoPlan(options.plan);
+  const backchain = boundPlanBackchain(plan, options.featureChain);
   verifyPlanNarrativeAnchors(repoRoot, plan);
   const genesis = buildPlanGenesis(plan, options.genesis);
   const tasks = replay(plan, [genesis]);
@@ -2962,6 +2991,7 @@ export async function initializeAuthoredTodoStore(options = {}) {
     await atomicWrite(path.join(stage, base, 'plan.json'), canonicalLine(plan));
     await atomicWrite(path.join(stage, base, 'journal', 'active.jsonl'), canonicalLine(genesis));
     await atomicWrite(path.join(stage, base, 'snapshot.json'), canonicalLine(snapshot));
+    if (backchain !== null) await atomicWrite(path.join(stage, base, 'backchain.json'), canonicalLine(backchain));
     await atomicWrite(path.join(stage, 'manifest.json'), canonicalLine(manifest));
 
     try {
@@ -3245,6 +3275,83 @@ function validatePhaseV3Carry(previous, revision, migration, idMap, state) {
   }
 }
 
+function validateBackchainCarry(previous, revision, migration, idMap) {
+  const decision = revision.backchain.continuity?.find(({ task_id: id }) =>
+    id === migration.from_task_id);
+  if (decision?.policy === 'carry') return;
+  const reconciliationMetadata = migration.state_policy === 'carry_reconciled_metadata';
+  const predecessorTask = previous.plan.tasks.find(({ task_id }) => task_id === migration.from_task_id);
+  const phaseIdMap = new Map(revision.phase_migration
+    .filter(({ from_phase_id, to_phase_id }) => from_phase_id !== null && to_phase_id !== 'removed')
+    .map(({ from_phase_id, to_phase_id }) => [from_phase_id, to_phase_id]));
+  const before = phaseV3CarrySemantics(previous.plan, migration.from_task_id, idMap, phaseIdMap, {
+    reconciliationMetadata, includeDesignMemo: !reconciliationMetadata
+      && typeof predecessorTask?.design_memo === 'string',
+    removedTaskIds: removedTaskIdsFor(revision),
+  });
+  const after = phaseV3CarrySemantics(revision.desired_plan, migration.to_task_id,
+    new Map(), new Map(), {
+      reconciliationMetadata, includeDesignMemo: !reconciliationMetadata
+        && typeof predecessorTask?.design_memo === 'string',
+    });
+  // 利用先の増減は提供済み機能の意味を変えない。入力・提供機能の同一性は
+  // backchain契約で別に照合し、工程の入力辺と本体の意味だけをここで検査する。
+  if (canonicalizeTodoArtifact(before.task) !== canonicalizeTodoArtifact(after.task)
+    || canonicalizeTodoArtifact(before.incoming) !== canonicalizeTodoArtifact(after.incoming)) {
+    fail('REVISION_INVALID', 'carry_semantics_changed', { from_task_id: migration.from_task_id });
+  }
+}
+
+function backchainTaskSignature(chain, taskId) {
+  const task = chain?.tasks?.find(({ task_id: id }) => id === taskId);
+  if (task === undefined) return null;
+  const featureIds = [...new Set([...task.requires_feature_ids, ...task.provides_feature_ids])].sort();
+  const byId = new Map(chain.features.map((feature) => [feature.feature_id, feature]));
+  return canonicalizeTodoArtifact({
+    requires_feature_ids: task.requires_feature_ids,
+    provides_feature_ids: task.provides_feature_ids,
+    features: featureIds.map((id) => byId.get(id)),
+  });
+}
+
+async function assertBackchainCarryContracts(repoRoot, previous, revision) {
+  const decisions = new Map((revision.backchain.continuity ?? [])
+    .map((entry) => [entry.task_id, entry]));
+  for (const decision of decisions.values()) {
+    const migration = revision.task_migration.find(({ from_task_id: id }) => id === decision.task_id);
+    if (migration === undefined || (decision.policy === 'carry'
+      && !['carry', 'carry_reconciled_metadata'].includes(migration.state_policy))
+      || (decision.policy === 'reset' && migration.state_policy !== 'reset_pending')
+      || (decision.policy === 'retire' && migration.state_policy !== 'removed')) {
+      fail('REVISION_INVALID', 'backchain_continuity_mismatch', { task_id: decision.task_id });
+    }
+  }
+  const carried = revision.task_migration.filter(({ state_policy }) =>
+    ['carry', 'carry_reconciled_metadata', 'acquire_phase'].includes(state_policy));
+  if (carried.length === 0) return;
+  const oldRef = path.resolve(repoRoot, STORE_ROOT_REF, 'plans', previous.plan.plan_key,
+    previous.plan.plan_version, 'backchain.json');
+  const bytes = await exactFileOrNull(oldRef);
+  if (bytes === null) fail('REVISION_INVALID', 'backchain_predecessor_missing');
+  let binding;
+  try { binding = JSON.parse(decodeUtf8(bytes, 'REVISION_INVALID', 'backchain_predecessor_invalid')); }
+  catch { fail('REVISION_INVALID', 'backchain_predecessor_invalid'); }
+  if (binding?.schema !== 'lattice.plan_backchain_binding.v1'
+    || binding.plan_digest !== previous.plan.plan_digest
+    || binding.binding_digest !== todoSelfDigest(binding, 'binding_digest')) {
+    fail('REVISION_INVALID', 'backchain_predecessor_invalid');
+  }
+  for (const migration of carried) {
+    if (decisions.get(migration.from_task_id)?.policy === 'carry') continue;
+    if (backchainTaskSignature(binding.chain, migration.from_task_id)
+      !== backchainTaskSignature(revision.backchain, migration.to_task_id)) {
+      fail('REVISION_INVALID', 'backchain_carry_feature_changed', {
+        from_task_id: migration.from_task_id, to_task_id: migration.to_task_id,
+      });
+    }
+  }
+}
+
 /**
  * acquire_phase専用のcarry検証(ADR 0147裁定4)。既存carry/carry_reconciled_metadataの
  * 分岐(validatePhaseV3Carry)には一切手を入れず、「Phase割当ての獲得だけ」を許す別分岐として
@@ -3330,6 +3437,8 @@ function stateMigrationFor(previous, revision) {
       }
     } else if (revision.schema === 'lattice.phase_todo_revision.v3') {
       validatePhaseV3Carry(previous, revision, migration, idMap, state);
+    } else if (revision.schema === 'lattice.phase_todo_revision.v4') {
+      validateBackchainCarry(previous, revision, migration, idMap);
     } else {
       const predecessorTask = previous.plan.tasks
         .find(({ task_id }) => task_id === migration.from_task_id);
@@ -4373,6 +4482,9 @@ export async function applyPhaseTodoRevision(options = {}) {
       fail('STORE_WRITE_CONFLICT', 'stale_predecessor');
     }
     verifyPlanNarrativeAnchors(repoRoot, revision.desired_plan, previous.plan);
+    if (revision.schema === 'lattice.phase_todo_revision.v4') {
+      await assertBackchainCarryContracts(repoRoot, previous, revision);
+    }
     const stateMigration = stateMigrationFor(previous, revision);
     const phaseStateMigration = phaseStateMigrationFor(previous, revision);
     const prospective = store.members.map((member) => member === previous
@@ -4417,6 +4529,9 @@ export async function applyPhaseTodoRevision(options = {}) {
       ['phase_revision_plan_durable', planRef, canonicalLine(revision.desired_plan)],
       ['phase_revision_genesis_durable', journalRef, canonicalLine(genesis)],
       ['phase_revision_snapshot_durable', snapshotRef, canonicalLine(snapshot)],
+      ...(revision.schema === 'lattice.phase_todo_revision.v4'
+        ? [['phase_revision_backchain_durable', `${base}/backchain.json`,
+          canonicalLine(boundPlanBackchain(revision.desired_plan, revision.backchain))]] : []),
     ];
     for (const [stage, ref, bytes] of artifacts) {
       const absolute = path.resolve(repoRoot, ref);