@quolu/lattice 0.46.2 → 0.47.0

package/src/runtime-contracts.mjs

@@ -235,14 +235,18 @@ const WITNESS_PROVENANCE = Object.freeze([
 ]);
 
 /**
- * 現行のrun request契約。v3は`owns[].creates`だけがv1との差であり、境界宣言としては同値である。
- * 既存requestの書き換えを要求しないため、v1は読み口として残す。
+ * 現行のrun request契約。v4は計画境界を予測として扱う。v3以前の厳密なcompile契約は、
+ * 既存requestの意味を変えないため読み口として残す。
  *
  * v2はこの系列ではない。ADR 0064のepoch後継request（`predecessor_request_digest`と
  * `task_migration_digest`を持つ別shape）が既に使っている番号なので、飛ばして採番する。
  */
-export const RUN_REQUEST_SCHEMA = 'lattice.run_request.v3';
-export const RUN_REQUEST_LEGACY_SCHEMAS = Object.freeze(['lattice.run_request.v1']);
+export const RUN_REQUEST_SCHEMA = 'lattice.run_request.v4';
+export const RUN_REQUEST_DECLARATIVE_SCHEMA = 'lattice.run_request.v3';
+export const RUN_REQUEST_LEGACY_SCHEMAS = Object.freeze([
+  RUN_REQUEST_DECLARATIVE_SCHEMA,
+  'lattice.run_request.v1',
+]);
 export const RUN_REQUEST_SCHEMAS = Object.freeze([
   RUN_REQUEST_SCHEMA,
   ...RUN_REQUEST_LEGACY_SCHEMAS,
@@ -305,7 +309,7 @@ export function explainRunRequest(value) {
   if (!exactRecord(value, RUN_REQUEST_FIELDS)) return reject('unexpected_or_missing_top_level_keys', '');
   if (!RUN_REQUEST_SCHEMAS.includes(value.schema)) return reject('schema_mismatch', '/schema');
   // 創作宣言はv2から。v1のclosed shapeは余分fieldを拒否するので加算互換が成立しない。
-  const allowCreates = value.schema === RUN_REQUEST_SCHEMA;
+  const allowCreates = [RUN_REQUEST_SCHEMA, RUN_REQUEST_DECLARATIVE_SCHEMA].includes(value.schema);
   if (!identifier(value.request_id)) return reject('invalid_identifier', '/request_id');
   if (!exactRecord(value.repo, ['base_sha', 'root_kind'])) return reject('unexpected_or_missing_keys', '/repo');
   if (!gitSha(value.repo.base_sha)) return reject('invalid_git_sha', '/repo/base_sha');

package/src/runtime-decision-verifier.mjs

@@ -124,12 +124,14 @@ function witnessSet(manifest, kinds) {
  * unknown findingにする。
  */
 export function classifyObservedDiff(options = {}) {
-  const { plan, manifests, observations } = options;
+  const { plan, manifests, observations, relevantTodoIds = null } = options;
   requirePlan(plan);
   if (manifests === null || typeof manifests !== 'object' || Array.isArray(manifests)
-    || !Array.isArray(observations)) {
+    || !Array.isArray(observations)
+    || !(relevantTodoIds === null || Array.isArray(relevantTodoIds))) {
     invalidVerification('manifests／observationsが不正');
   }
+  const relevant = new Set(relevantTodoIds ?? Object.keys(manifests));
 
   const findings = [];
   const observedByTodo = new Map();
@@ -187,7 +189,8 @@ export function classifyObservedDiff(options = {}) {
   for (const [todoId, paths] of observedByTodo) {
     for (const [otherId, manifest] of Object.entries(manifests)) {
       if (otherId === todoId) continue;
-      const otherDeclared = manifest.writes ?? [];
+      if (!relevant.has(otherId)) continue;
+      const otherDeclared = [...(manifest.reads ?? []), ...(manifest.writes ?? [])];
       for (const path of paths) {
         if (!declaredWriteCovers(otherDeclared, path)) continue;
         const pair = sorted([todoId, otherId]);
@@ -453,6 +456,24 @@ export function recomputeReceiptDecisions(options = {}) {
     const dispatch = dispatchEventForReceipt === undefined
       ? undefined
       : { sequence: dispatchEventForReceipt.sequence, payload: dispatchEventForReceipt.payload };
+    const originBindingRetained = (() => {
+      if (!Number.isSafeInteger(receipt.plan_epoch) || receipt.plan_epoch >= plan.plan_epoch) return false;
+      for (let epoch = receipt.plan_epoch; epoch < plan.plan_epoch; epoch += 1) {
+        const witnessed = events.some((event) => event.sequence < receipt.sequence
+          && event.kind === 'carry_over_witnessed' && event.plan_epoch === epoch
+          && event.subject?.kind === 'todo' && event.subject.ref === receipt.todo_id);
+        const continued = events.some((event) => event.sequence < receipt.sequence
+          && event.kind === 'hold_decided' && event.plan_epoch === epoch
+          && event.payload?.continue_set?.includes(receipt.todo_id));
+        const recompiled = events.some((event) => event.sequence < receipt.sequence
+          && event.kind === 'plan_recompiled' && event.plan_epoch === epoch + 1);
+        const invalidated = events.some((event) => event.sequence < receipt.sequence
+          && event.kind === 'context_invalidated' && event.plan_epoch === epoch + 1
+          && event.subject?.kind === 'todo' && event.subject.ref === receipt.todo_id);
+        if (!witnessed || !continued || !recompiled || invalidated) return false;
+      }
+      return true;
+    })();
     if (dispatch === undefined) {
       return reject('not_dispatched');
     }
@@ -465,12 +486,12 @@ export function recomputeReceiptDecisions(options = {}) {
     if (typeof plan.base_sha === 'string' && payload.base_sha !== plan.base_sha) {
       return reject('base_mismatch');
     }
-    if (receipt.plan_epoch !== plan.plan_epoch) {
+    if (receipt.plan_epoch !== plan.plan_epoch && !originBindingRetained) {
       return reject('epoch_mismatch');
     }
     // dispatchが旧epochのTODOが現epoch receiptを名乗る場合はepoch_rebound必須
     // （rebindなしのepoch自称を受理しない。Decision 7.3/7.4）。
-    if (dispatchEventForReceipt.plan_epoch !== plan.plan_epoch) {
+    if (dispatchEventForReceipt.plan_epoch !== plan.plan_epoch && !originBindingRetained) {
       const rebound = state.rebinds[receipt.todo_id];
       if (rebound === undefined
         || rebound.payload?.new_plan_epoch !== plan.plan_epoch

package/src/runtime-engine.mjs

@@ -391,6 +391,22 @@ export async function observeExecutor(options = {}) {
     if (!validateExecutorReceipt(observation.receipt)) {
       fail(`terminal receiptがexecutor_receipt.v1 contractを満たさない: ${todoId}`);
     }
+    if (observation.checkpoint !== undefined) {
+      if (!plainRecord(observation.checkpoint)
+        || typeof observation.checkpoint.checkpoint_digest !== 'string'
+        || !/^[0-9a-f]{64}$/.test(observation.checkpoint.checkpoint_digest)) {
+        fail(`terminal checkpointにはcheckpoint_digestが必要: ${todoId}`);
+      }
+      next.push(buildNextRunEvent({
+        events: next,
+        runId,
+        kind: 'checkpoint_observed',
+        planEpoch: observation.receipt.plan_epoch,
+        subject: { kind: 'todo', ref: todoId },
+        payload: structuredClone(observation.checkpoint),
+        recordedAt,
+      }));
+    }
     next.push(buildNextRunEvent({
       events: next,
       runId,
@@ -481,13 +497,19 @@ export function classifyCheckpointObservation(options = {}) {
   const checkpoints = state.checkpoints.filter((entry) => entry.todo_id === todoId);
   if (checkpoints.length === 0) fail(`checkpoint未観測のTODOを分類できない: ${todoId}`);
   const checkpoint = checkpoints[checkpoints.length - 1].payload;
-  const { findings } = detect({
+  const { findings: detectedFindings } = detect({
     todoId,
     checkpoint,
     packets,
     runningTodoIds: state.running,
   });
-  if (!Array.isArray(findings)) fail('detectがfindings配列を返さない');
+  if (!Array.isArray(detectedFindings)) fail('detectがfindings配列を返さない');
+  const observations = detectedFindings
+    .filter((finding) => finding.kind === 'undeclared_write' && finding.todo_ids?.length === 1)
+    .map((finding) => ({ ...finding, kind: 'prediction_excess' }));
+  const findings = detectedFindings.filter((finding) => !(
+    finding.kind === 'undeclared_write' && finding.todo_ids?.length === 1
+  ));
   // 再分類のidempotence: 既に保存済みのfinding（kind＋todo_ids＋path）は再記録しない。
   const recordedKeys = new Set(state.conflicts.map((conflict) => (
     `${conflict.kind}|${[...(conflict.todo_ids ?? [])].sort().join(',')}|${conflict.path ?? ''}`
@@ -521,7 +543,7 @@ export function classifyCheckpointObservation(options = {}) {
       recordedAt,
     }));
   }
-  return { events: next, findings: freshFindings };
+  return { events: next, findings: freshFindings, observations };
 }
 
 const RECEIPT_BINDING_FIELDS = Object.freeze([
@@ -549,6 +571,25 @@ function witnessProvenReceiptBinding(state, receipt) {
   ));
 }
 
+function retainsOriginBinding(events, receipt, currentEpoch) {
+  if (!Number.isSafeInteger(receipt.plan_epoch) || receipt.plan_epoch >= currentEpoch) return false;
+  for (let epoch = receipt.plan_epoch; epoch < currentEpoch; epoch += 1) {
+    const witnessed = events.some((event) => event.sequence < receipt.sequence
+      && event.kind === 'carry_over_witnessed' && event.plan_epoch === epoch
+      && event.subject?.kind === 'todo' && event.subject.ref === receipt.todo_id);
+    const continued = events.some((event) => event.sequence < receipt.sequence
+      && event.kind === 'hold_decided' && event.plan_epoch === epoch
+      && event.payload?.continue_set?.includes(receipt.todo_id));
+    const recompiled = events.some((event) => event.sequence < receipt.sequence
+      && event.kind === 'plan_recompiled' && event.plan_epoch === epoch + 1);
+    const invalidated = events.some((event) => event.sequence < receipt.sequence
+      && event.kind === 'context_invalidated' && event.plan_epoch === epoch + 1
+      && event.subject?.kind === 'todo' && event.subject.ref === receipt.todo_id);
+    if (!witnessed || !continued || !recompiled || invalidated) return false;
+  }
+  return true;
+}
+
 export function adjudicatePendingReceipts(options = {}) {
   if (!exactRecord(options, ['runId', 'plan', 'events', 'recordedAt'])) {
     fail('adjudicatePendingReceipts optionsがexact shapeでない');
@@ -577,6 +618,7 @@ export function adjudicatePendingReceipts(options = {}) {
     if (receipt.accepted_sequence !== null || receipt.rejected_sequence !== null) continue;
     const payload = receipt.payload ?? {};
     const dispatch = state.dispatches[receipt.todo_id];
+    const originBindingRetained = retainsOriginBinding(events, receipt, plan.plan_epoch);
     let rejection = null;
     if (seenReceiptIds.has(receipt.receipt_id)) {
       rejection = 'duplicate_receipt_id';
@@ -590,7 +632,7 @@ export function adjudicatePendingReceipts(options = {}) {
       rejection = 'binding_mismatch';
     } else if (payload.base_sha !== plan.base_sha) {
       rejection = 'base_mismatch';
-    } else if (receipt.plan_epoch !== plan.plan_epoch) {
+    } else if (receipt.plan_epoch !== plan.plan_epoch && !originBindingRetained) {
       rejection = 'epoch_mismatch';
     } else if ((() => {
       // dispatchが旧epochのTODOが現epochのreceiptを名乗る場合、epoch_rebound
@@ -602,7 +644,8 @@ export function adjudicatePendingReceipts(options = {}) {
         && event.subject.ref === receipt.todo_id
         && event.sequence === dispatch.sequence
       ));
-      if (dispatchEvent === undefined || dispatchEvent.plan_epoch === plan.plan_epoch) return false;
+      if (originBindingRetained || dispatchEvent === undefined
+        || dispatchEvent.plan_epoch === plan.plan_epoch) return false;
       const rebound = state.rebinds[receipt.todo_id];
       return rebound === undefined
         || rebound.payload?.new_plan_epoch !== plan.plan_epoch

package/src/runtime-front-end.mjs

@@ -7,6 +7,7 @@ import { compileSchedulabilityGraphV2 } from './schedulability-compiler-v2.mjs';
 import { verifySchedulabilityPlanV2 } from './schedulability-verifier-v2.mjs';
 import {
   BOUNDARY_MANIFEST_SCHEMA,
+  RUN_REQUEST_SCHEMA,
   SENSOR_EXPECT_KINDS,
   SENSOR_QUERY_OPERATIONS,
   selfDigest,
@@ -447,6 +448,7 @@ export function compileRuntimePlanV1(options = {}) {
   const outcomeByQueryId = normalizeEvidence(sensorEvidence, queryById);
 
   const todoIds = request.todos.map((todo) => todo.todo_id);
+  const predictionsOnly = request.schema === RUN_REQUEST_SCHEMA;
 
   // witnessの束縛を解決する。query set外の参照と、expect↔query targetの
   // 不一致（別targetのreceiptへの再ラベル）はQUERY_DRIFT。
@@ -458,7 +460,7 @@ export function compileRuntimePlanV1(options = {}) {
     const creating = new Set(witness.owns
       .filter((own) => own.creates === true).map((own) => own.target));
     const bindings = normalizeProvenanceQueries(witness, todoId)
-      .map((binding) => (creating.size > 0
+      .map((binding) => (!predictionsOnly && creating.size > 0
         && [...creating].some((target) => bindingCoversOwn(binding, { kind: 'path', target }))
         ? { ...binding, creates: true } : binding));
     for (const binding of bindings) {
@@ -498,7 +500,7 @@ export function compileRuntimePlanV1(options = {}) {
   for (const todoId of todoIds) {
     for (const binding of bindingsByTodo.get(todoId)) {
       const resolved = resolveBindingStatus(binding, outcomeByQueryId.get(binding.query_id));
-      if (resolved !== 'ready') {
+      if (!predictionsOnly && resolved !== 'ready') {
         unknowns.push({ todo_id: todoId, kind: `sensor_${resolved}`, ref: binding.query_id });
       }
     }
@@ -544,7 +546,7 @@ export function compileRuntimePlanV1(options = {}) {
       });
     }
   }
-  if (affectedDrift.length > 0) {
+  if (!predictionsOnly && affectedDrift.length > 0) {
     return nonDispatchable('AFFECTED_TEST_DRIFT', { mismatches: affectedDrift });
   }
 
@@ -570,14 +572,16 @@ export function compileRuntimePlanV1(options = {}) {
           ambiguous.push({ target: own.target, query_ids: [seen, binding.query_id].sort(compareText) });
         }
       }
-      if (covering.length === 0) {
+      if (!predictionsOnly && covering.length === 0) {
         unknowns.push({ todo_id: todoId, kind: 'sensor_unbound', ref: `${own.kind}:${own.target}` });
       }
     }
   }
   if (ambiguous.length > 0) return nonDispatchable('QUERY_DRIFT', { ambiguous_targets: ambiguous });
 
-  // 宣言write scopeの交差はownership解決なしでは安全と推測できない（unknownへ）。
+  // 最新契約ではwrite scopeは予測である。既知の交差はserial conflictへ使うが、
+  // 予測が足りないこと自体はunknownへ落とさない。
+  const predictedWriteGroups = [];
   for (let left = 0; left < todoIds.length; left += 1) {
     for (let right = left + 1; right < todoIds.length; right += 1) {
       const leftWitness = request.manual_witness[todoIds[left]];
@@ -591,16 +595,21 @@ export function compileRuntimePlanV1(options = {}) {
           // resource経由で扱われる。owns解決のない交差だけをunknownにする。
           if (leftOwnPaths.has(leftPath) && rightOwnPaths.has(rightPath)
             && leftPath === rightPath) continue;
-          unknowns.push({
-            todo_id: todoIds[left],
-            kind: 'undeclared_write_overlap',
-            ref: `${leftPath} ${rightPath}`,
-          });
-          unknowns.push({
-            todo_id: todoIds[right],
-            kind: 'undeclared_write_overlap',
-            ref: `${leftPath} ${rightPath}`,
-          });
+          if (predictionsOnly) {
+            predictedWriteGroups.push({
+              target: [leftPath, rightPath].sort(compareText).join(' ↔ '),
+              todoIds: [todoIds[left], todoIds[right]],
+            });
+          } else {
+            unknowns.push({
+              todo_id: todoIds[left], kind: 'undeclared_write_overlap',
+              ref: `${leftPath} ${rightPath}`,
+            });
+            unknowns.push({
+              todo_id: todoIds[right], kind: 'undeclared_write_overlap',
+              ref: `${leftPath} ${rightPath}`,
+            });
+          }
         }
       }
     }
@@ -661,6 +670,7 @@ export function compileRuntimePlanV1(options = {}) {
       if (representative !== undefined) break;
     }
     if (representative === undefined) fail(`covering binding不整合: ${group.own.target}`);
+    if (predictionsOnly && resolveBindingStatus(representative, outcome) !== 'ready') continue;
     const status = statusOutcome.status !== 'ready'
       ? statusOutcome.status
       : resolveBindingStatus(representative, outcome);
@@ -722,6 +732,15 @@ export function compileRuntimePlanV1(options = {}) {
       provenance: [manualProvenance(request)],
     });
   }
+  for (const [index, group] of predictedWriteGroups.entries()) {
+    resources.push({
+      resource_id: `predicted-ww-${sha16(`${group.target}:${index}`)}`,
+      kind: 'state',
+      target: group.target,
+      todo_ids: group.todoIds,
+      provenance: [manualProvenance(request)],
+    });
+  }
 
   let dynamicIndex = 0;
   for (const unknown of unknowns) {

package/src/runtime-hold-recompile.mjs

@@ -301,6 +301,11 @@ function computeAffectedClosure(plan, manifests, seedTodoIds) {
   return closure;
 }
 
+/** runtime findingから、停止・再計画する作業群だけを取り出す。 */
+export function affectedTodoIds(plan, manifests, seedTodoIds) {
+  return sorted(computeAffectedClosure(plan, manifests, seedTodoIds));
+}
+
 /**
  * carry-over witness documentを構築し、提供sourcesに対して自己実証する。
  * 実証できない場合はnullでなくreasons付きの失敗を返す（呼び出し側がholdへ戻す）。
@@ -754,9 +759,9 @@ export function recompileNextEpochPlan(options = {}) {
     recordedAt,
   }));
 
-  // 旧contextの全失効（Decision 7: 例外なく一斉失効。carried-overは失効後に
-  // rebindで「内容同一性を証明した新epochへの再認可」を受ける）。
-  for (const todoId of sorted([...holdDecision.hold_set, ...holdDecision.continue_set])) {
+  // 失効するのは停止・再計画対象だけ。closure外のrunning TODOはorigin bindingのまま
+  // 継続するため、contextもpartial patchも無効化しない。
+  for (const todoId of sorted(holdDecision.hold_set)) {
     next.push(buildNextRunEvent({
       events: next,
       runId,
@@ -766,7 +771,7 @@ export function recompileNextEpochPlan(options = {}) {
       payload: {
         old_plan_ref: plan.plan_ref,
         invalidated: ['agent_context', 'partial_patch', 'interface_assumption', 'boundary_evidence'],
-        reauthorized_via: holdDecision.continue_set.includes(todoId) ? 'epoch_rebind' : 'redispatch',
+        reauthorized_via: 'redispatch',
       },
       recordedAt,
     }));
@@ -788,7 +793,8 @@ export function recompileNextEpochPlan(options = {}) {
     .map((event) => event.sequence)
     .sort((left, right) => left - right)[0] ?? null;
 
-  // carried-over TODOへのepoch rebind packet（content不変・epoch/plan refだけ更新）。
+  // restart時は全process barrierになるため、その場合だけcarry-overを現epochへ復元できる
+  // rebind packetをbundleへ残す。通常のrecompileでは使わずorigin bindingを維持する。
   const rebindPackets = {};
   for (const todoId of holdDecision.continue_set) {
     const packet = packets[todoId];

package/src/runtime-managed-supervisor.mjs

@@ -262,6 +262,7 @@ export class RuntimeManagedSupervisor {
   #gate = null;
   #previousGate = null;
   #releaseAcks = [];
+  #gateRecords = new Map();
   #frozen = false;
   #gateGeneration = 0;
 
@@ -321,10 +322,8 @@ export class RuntimeManagedSupervisor {
       || !Number.isSafeInteger(sequence) || sequence <= record.lastHeartbeatSequence || !digest(leaseSetDigest)) {
       await this.#failClosed(record, 'CONTROLLER_HEARTBEAT_EXPIRED', 'heartbeat binding不正');
     }
-    const expectedLeaseSetDigest = digestArtifact([...this.#leases.values()]
-      .filter((entry) => entry.controllerId === controllerId && !entry.revoked)
-      .map((entry) => entry.lease.lease_digest).sort());
-    if (leaseSetDigest !== expectedLeaseSetDigest) await this.#failClosed(record, 'CONTROLLER_HEARTBEAT_EXPIRED', 'heartbeat lease set不一致');
+    // prepare/release応答とsupervisor投影の間には短い非同期窓がある。heartbeatは
+    // livenessだけを担い、lease集合はwrite認可時のcentral gate full-chainで照合する。
     record.lastHeartbeat = this.#clock();
     record.lastHeartbeatSequence = sequence;
     await this.#append('controller_heartbeat', { controller_id: controllerId, registration_digest: registrationDigest, sequence, lease_set_digest: leaseSetDigest });
@@ -366,13 +365,30 @@ export class RuntimeManagedSupervisor {
 
   /** 全running bindingを一件も省略せずbarrierし、controller ackと独立OS観測を照合する。 */
   async barrierAll({ barrierId, reason, frozenEventDigest }) {
+    return this.#barrier({ barrierId, reason, frozenEventDigest, targetTodoIds: null });
+  }
+
+  /** findingの影響群だけを静止し、無関係なrunning bindingはそのまま通す。 */
+  async barrierSelected({ barrierId, reason, frozenEventDigest, todoIds }) {
+    if (!Array.isArray(todoIds) || todoIds.length === 0
+      || todoIds.some((todoId) => !identifier(todoId))
+      || new Set(todoIds).size !== todoIds.length) {
+      fail('HOLD_ACKS_INCOMPLETE', '対象barrierのTODO集合が不正');
+    }
+    return this.#barrier({ barrierId, reason, frozenEventDigest,
+      targetTodoIds: new Set(todoIds) });
+  }
+
+  async #barrier({ barrierId, reason, frozenEventDigest, targetTodoIds }) {
     const durableBindings = await this.#runningBindingResolver({ runId: this.#runId, frozenEventDigest });
     if (!identifier(barrierId) || typeof reason !== 'string' || reason.length === 0
       || !digest(frozenEventDigest) || !Array.isArray(durableBindings)
       || !durableBindings.every(validateRunningBinding)) fail('HOLD_ACKS_INCOMPLETE', 'durable running binding不正');
     await this.assertControllerHealth();
     this.#frozen = true;
-    const runningBindings = await this.#resolveRunningUnion({ durableBindings, frozenEventDigest });
+    const allRunningBindings = await this.#resolveRunningUnion({ durableBindings, frozenEventDigest });
+    const runningBindings = targetTodoIds === null ? allRunningBindings
+      : allRunningBindings.filter((binding) => targetTodoIds.has(binding.todo_id));
     const unique = new Set(runningBindings.map((binding) => binding.todo_id));
     if (unique.size !== runningBindings.length) fail('HOLD_ACKS_INCOMPLETE', 'running TODO重複');
     const barrierControlDigest = await this.#append('barrier_requested', { barrier_id: barrierId,
@@ -413,7 +429,9 @@ export class RuntimeManagedSupervisor {
       }
     }
     if (acknowledgements.length !== runningBindings.length) fail('HOLD_ACKS_INCOMPLETE', '未登録controller所有bindingあり');
-    const residualBindings = await this.#collectControllerRunning({ frozenEventDigest });
+    const observedAfterBarrier = await this.#collectControllerRunning({ frozenEventDigest });
+    const residualBindings = targetTodoIds === null ? observedAfterBarrier
+      : observedAfterBarrier.filter((binding) => targetTodoIds.has(binding.todo_id));
     if (residualBindings.length !== 0) {
       fail('HOLD_ACKS_INCOMPLETE', `barrier後もrunning executor残存: ${residualBindings.map((binding) => binding.todo_id).join(',')}`);
     }
@@ -460,10 +478,14 @@ export class RuntimeManagedSupervisor {
     return observed;
   }
 
-  /** finding/store永続化後に呼ぶtyped hold閉路。全running quiescence以外はheldを返さない。 */
-  async holdConflict({ findingDigest, frozenEventDigest, barrierId, reason, recordedAt }) {
+  /** finding/store永続化後に呼ぶtyped hold閉路。対象群のquiescence完了後だけheldを返す。 */
+  async holdConflict({ findingDigest, frozenEventDigest, barrierId, reason, recordedAt,
+    todoIds = null }) {
     if (!digest(findingDigest) || typeof recordedAt !== 'string' || Number.isNaN(Date.parse(recordedAt))) fail('FINDING_UNRESOLVED', 'hold finding binding不正');
-    const acknowledgements = await this.barrierAll({ barrierId, reason, frozenEventDigest });
+    const acknowledgements = todoIds === null
+      ? await this.barrierAll({ barrierId, reason, frozenEventDigest })
+      : await this.barrierSelected({ barrierId, reason, frozenEventDigest,
+        todoIds });
     const result = {
       schema: 'lattice.runtime_hold_result.v1', run_id: this.#runId,
       finding_digest: findingDigest, barrier_id: barrierId,
@@ -635,6 +657,10 @@ export class RuntimeManagedSupervisor {
     this.#previousGate = this.#gate;
     this.#gate = gate;
     this.#releaseAcks = releaseAcks.map((ack) => structuredClone(ack));
+    this.#gateRecords.set(gate.gate_generation, {
+      gate: structuredClone(gate),
+      releaseAcks: releaseAcks.map((ack) => structuredClone(ack)),
+    });
     this.#gateGeneration = nextGeneration;
     this.#frozen = false;
     return { gate: structuredClone(gate), armedLeases: armed.map((lease) => structuredClone(lease)) };
@@ -644,19 +670,32 @@ export class RuntimeManagedSupervisor {
   async authorizeWrite({ leaseDigest }) {
     await this.assertControllerHealth();
     const entry = this.#leases.get(leaseDigest);
-    if (this.#frozen || !entry || entry.revoked || !validateArmedWriteLease(entry.lease) || this.#gate === null) fail('RUN_FROZEN', '有効なarmed leaseなし');
+    if (this.#frozen || !entry || entry.revoked || !validateArmedWriteLease(entry.lease)) fail('RUN_FROZEN', '有効なarmed leaseなし');
+    const gateRecord = this.#gateRecords.get(entry.lease.gate_generation);
+    const gate = gateRecord?.gate ?? (this.#gate?.gate_generation === entry.lease.gate_generation
+      ? this.#gate : null);
+    const releaseAcks = gateRecord?.releaseAcks ?? (gate === this.#gate ? this.#releaseAcks : []);
+    if (gate === null) fail('RUN_FROZEN', 'leaseのorigin gateが無い');
+    const previousGate = this.#gateRecords.get(gate.gate_generation - 1)?.gate
+      ?? (gate === this.#gate ? this.#previousGate : null);
+    const gateLeases = [...this.#leases.values()]
+      .filter((item) => !item.revoked && validateArmedWriteLease(item.lease)
+        && item.lease.gate_generation === gate.gate_generation)
+      .map((item) => item.lease);
     const verified = verifyCentralWriteGate({
-      gate: this.#gate, runId: this.#runId, planEpoch: entry.lease.plan_epoch,
+      gate, runId: this.#runId, planEpoch: entry.lease.plan_epoch,
       releaseBarrierDigest: entry.lease.release_barrier_digest, sessionNonceDigest: this.#sessionNonceDigest,
       registrations: [...this.#controllers.values()].map((record) => record.registration),
       controllers: [...this.#controllers.values()].map((record) => record.descriptor),
-      releaseAcks: this.#releaseAcks, armedLeases: [...this.#leases.values()].filter((item) => !item.revoked && validateArmedWriteLease(item.lease)).map((item) => item.lease),
-      previousGate: this.#previousGate,
+      releaseAcks, armedLeases: gateLeases,
+      previousGate,
     });
-    if (!verified.valid || this.#clock() - entry.issuedAt > entry.lease.ttl_ms) {
+    // gate commit時にarmした後続frontierのleaseを壁時計で失効させると、正しく直列待ちした
+    // taskほどdispatch不能になる。freshnessはactive gate chainとrevokeで決める。
+    if (!verified.valid) {
       entry.revoked = true;
       this.#frozen = true;
-      fail('RUN_FROZEN', verified.valid ? 'lease TTL超過' : verified.reason);
+      fail('RUN_FROZEN', verified.reason);
     }
     return structuredClone(entry.lease);
   }

package/src/runtime-scripted-adapter-controller.mjs

@@ -340,7 +340,8 @@ async function readAndValidateGate(runDir, writeLease) {
  *
  * 読むのは3つだけ:
  * - `hold_ms`: 書き込み後にworkerが走り続ける時間。実行時観測が成立する窓を作る。
- * - `extra_writes`: 宣言scope外へのwrite。競合検知そのものを検証するために要る。
+ * - `extra_writes`: 全TODOに共通する宣言scope外write。
+ * - `extra_writes_by_todo`: 競合当事者だけへscope外writeを与える実daemon fixture用設定。
  * - `mode`: 既存の`deterministic`のみ。未知の値は黙って無視せず止める。
  */
 async function readScriptedBehavior(repoRoot) {
@@ -351,10 +352,10 @@ async function readScriptedBehavior(repoRoot) {
     descriptor = JSON.parse(await readFile(descriptorPath, 'utf8'));
   } catch {
     // 未登録のまま走らせる経路（unit test等）は既定の振る舞いで動かす。
-    return { hold_ms: 0, extra_writes: [] };
+    return { hold_ms: 0, extra_writes: [], extra_writes_by_todo: {} };
   }
   if (typeof descriptor?.config_ref !== 'string' || typeof descriptor.config_digest !== 'string') {
-    return { hold_ms: 0, extra_writes: [] };
+    return { hold_ms: 0, extra_writes: [], extra_writes_by_todo: {} };
   }
   const configPath = path.join(repoRoot, ...descriptor.config_ref.split('/'));
   let bytes;
@@ -387,7 +388,15 @@ async function readScriptedBehavior(repoRoot) {
   if (!Array.isArray(extraWrites) || extraWrites.some((entry) => !safeWritePath(entry))) {
     fail('SCRIPTED_BOOTSTRAP_INVALID', 'extra_writesが不正');
   }
-  return { hold_ms: holdMs, extra_writes: [...extraWrites] };
+  const extraWritesByTodo = config?.extra_writes_by_todo ?? {};
+  if (!plain(extraWritesByTodo) || Object.entries(extraWritesByTodo).some(([todoId, entries]) => (
+    !ID.test(todoId) || !Array.isArray(entries) || entries.some((entry) => !safeWritePath(entry))
+  ))) {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', 'extra_writes_by_todoが不正');
+  }
+  return { hold_ms: holdMs, extra_writes: [...extraWrites],
+    extra_writes_by_todo: Object.fromEntries(Object.entries(extraWritesByTodo)
+      .map(([todoId, entries]) => [todoId, [...entries]])) };
 }
 
 const WORKER_ENTRYPOINT = fileURLToPath(new URL('../bin/lattice-scripted-worker.mjs', import.meta.url));
@@ -675,20 +684,34 @@ export async function createScriptedAdapterController({
       const priorHandle = todoToHandle.get(packet.todo_id);
       if (priorHandle !== undefined) {
         const prior = tasks.get(priorHandle);
-        if (prior.packet.packet_digest !== packet.packet_digest
-          || prior.lease.lease_digest !== writeLease.lease_digest) {
+        if (prior.packet.packet_digest === packet.packet_digest
+          && prior.lease.lease_digest === writeLease.lease_digest) {
+          return sign({
+            schema: 'lattice.adapter_dispatch_response.v2',
+            request_id: request.request_id,
+            executor_handle: prior.executorHandle,
+            worktree_id: prior.worktreeId,
+            packet_digest: packet.packet_digest,
+            lease_digest: writeLease.lease_digest,
+            worker_process: workerProcessOf(prior),
+            response_digest: '',
+          }, 'response_digest');
+        }
+        if (prior.state !== 'held') {
           fail('SCRIPTED_DUPLICATE_DISPATCH', '同じTODOへ異なるpacketをdispatchできない');
         }
-        return sign({
-          schema: 'lattice.adapter_dispatch_response.v2',
-          request_id: request.request_id,
-          executor_handle: prior.executorHandle,
-          worktree_id: prior.worktreeId,
-          packet_digest: packet.packet_digest,
-          lease_digest: writeLease.lease_digest,
-          worker_process: workerProcessOf(prior),
-          response_digest: '',
-        }, 'response_digest');
+        // 対象限定holdで失効したattemptだけを畳み、同じTODOのsuccessorを起動する。
+        // closure外attemptはtodoToHandleを保持するので、この経路へ入らない。
+        try { process.kill(-prior.worker.process_group_id, 'SIGKILL'); }
+        catch (error) {
+          if (error?.code !== 'ESRCH') {
+            fail('SCRIPTED_EXECUTION_FAILED', '旧attemptを終了できない', {
+              pid: prior.worker.pid, reason: String(error?.code ?? error?.message ?? error),
+            });
+          }
+        }
+        prior.state = 'superseded';
+        todoToHandle.delete(packet.todo_id);
       }
       await readAndValidateGate(canonicalRunDir, writeLease);
       // canonical repoではなく自分の木へ書く。共有rootでは、書き込みの帰属をrootから
@@ -722,7 +745,8 @@ export async function createScriptedAdapterController({
       // `detached`で独立process groupへ置く。同じgroupにcontrollerが居ると、直接OS観測が
       // 「未記録process group memberを検出」として正しく落とす。
       const spawned = await spawnScriptedWorker({
-        packet, worktreePath: worktreeReal, extraWrites: behavior.extra_writes,
+        packet, worktreePath: worktreeReal,
+        extraWrites: behavior.extra_writes_by_todo[packet.todo_id] ?? behavior.extra_writes,
         holdMs: behavior.hold_ms, controllerId, runDir: canonicalRunDir,
       });
       const task = {
@@ -1038,9 +1062,9 @@ export async function runScriptedAdapterController({
     registrationDigest = digest;
     if (heartbeatTimer !== null) return;
     heartbeatTimer = setInterval(() => {
-      if (socket.destroyed) return;
+      if (persistentSocket === null || persistentSocket.destroyed) return;
       heartbeatSequence += 1;
-      send(socket, sign({
+      send(persistentSocket, sign({
         schema: 'lattice.adapter_controller_heartbeat.v1',
         controller_id: controller.controllerId,
         registration_digest: registrationDigest,

package/src/runtime-seam-resolve.mjs

@@ -23,6 +23,7 @@ import { affectedTestsFromEvidence } from './runtime-front-end.mjs';
 import { explainSeamGate } from './seam-gate.mjs';
 import { collectWitnessSensorEvidence, compileTodoIndependence } from './todo-independence.mjs';
 import { todoSelfDigest } from './todo-contracts.mjs';
+import { TODO_WITNESS_SET_SCHEMA } from './todo-independence-contracts.mjs';
 
 export const RUNTIME_SEAM_REQUEST_SCHEMA = 'lattice.runtime_seam_request.v1';
 // v2は翻訳段（`reconciled`）の追加である。宣言を観測へ合わせてから判定するようになったので、
@@ -184,7 +185,7 @@ export function reconcileWitnessToObservation({
 /**
  * 実行時witnessへconcern anchorを足してtodo witness setにする。
  *
- * 実行時のmanual_witnessはconcern_anchorsを持たない（`lattice.run_request.v3`）。持たせるのでなく、
+ * 実行時のmanual_witnessはconcern_anchorsを持たない（`lattice.run_request.v4`）。持たせるのでなく、
  * 宣言から足す——係争資源の中のどのsymbolを触るかは実行時に確定する情報であり、run開始時点の
  * 契約に書けるものではないからである。
  *
@@ -213,7 +214,7 @@ export function buildRuntimeSeamWitnessSet({
     };
   }
   const witnessSet = {
-    schema: 'lattice.todo_witness_set.v3',
+    schema: TODO_WITNESS_SET_SCHEMA,
     project_id: SYNTHETIC_PLAN_KEY,
     plan_key: SYNTHETIC_PLAN_KEY,
     capacity: { executors },
@@ -315,6 +316,7 @@ export async function resolveRuntimeSeam({
         latticeBin,
         sharedPathFor: () => declaration.path_names.shared,
         executors: request.capacity.executors,
+        precedences: bundle.plan.precedence,
         pathNames,
         compileIndependence: {
           baseArtifact,