@quolu/lattice 0.46.2 → 0.48.0

package/src/runtime-cli.mjs

@@ -59,6 +59,7 @@ import {
 import { verifyRunEventChain } from './runtime-event-store.mjs';
 import { projectRuntimeState, projectRuntimeStatusOverlays } from './runtime-projection.mjs';
 import {
+  affectedTodoIds,
   decideHoldAndCarryOver,
   recompileNextEpochPlan,
   validateRuntimeRecompileRequest,
@@ -757,46 +758,6 @@ async function readScriptedControllerReceipt({
   return receipt;
 }
 
-/**
- * hold裁定をworker processへ反映する（請求項7・8の再開側）。
- *
- * **barrierは全workerを止める。** 静止の証明はrun全体に対して要るからである。hold裁定は
- * 止めた相手を`hold_set`と`continue_set`へ分け、後者は「影響閉包の外なので作業を捨てない」
- * と判定されたものである。
- *
- * **carry-overは「一度も止まらない」ではない。** rebindは静止を要求する
- * （`write_enabled === false`）ので、holdの直後に再開すると後継epochへ束ね直せず
- * `EPOCH_REBIND_INCOMPLETE`で落ちる。止まり、繋がれ、そこで動き出すのが正しい順序である。
- * よってこの関数を呼ぶのはrebindが済んだ後だけとする。
- *
- * pidだけで再開しない。pidは再利用されるので、start identityを照合して記録と同じprocessで
- * あることを確かめる——別のprocessをSIGCONTするのは、止めるのと同じくらい危険である。
- */
-async function resumeContinuedWorkers({ events, todoIds }) {
-  if (!Array.isArray(todoIds) || todoIds.length === 0) return { resumed: [], skipped: [] };
-  const resumed = [];
-  const skipped = [];
-  for (const todoId of todoIds) {
-    const dispatch = events.findLast((event) => event.kind === 'executor_dispatched'
-      && event.subject?.kind === 'todo' && event.subject.ref === todoId);
-    const binding = dispatch?.payload?.direct_os_observation_binding;
-    const pid = binding?.process_pid;
-    const recorded = binding?.process_start_identity?.identity_digest;
-    if (!Number.isSafeInteger(pid) || typeof recorded !== 'string') continue;
-    // pidは再利用される。記録と同じprocessであることを確かめてから再開する——
-    // 別のprocessをSIGCONTするのは、止めるのと同じくらい危険である。
-    const observed = await observeManagedProcessStartIdentity(pid).catch(() => null);
-    if (observed === null || observed.identity_digest !== recorded) {
-      skipped.push({ todo_id: todoId, reason: observed === null ? 'process不在' : 'start identity不一致' });
-      continue;
-    }
-    try { process.kill(pid, 'SIGCONT'); resumed.push(todoId); } catch {
-      skipped.push({ todo_id: todoId, reason: 'SIGCONT失敗' });
-    }
-  }
-  return { resumed, skipped };
-}
-
 /**
  * runが起こしたworker processを、耐久記録から回収する。
  *
@@ -831,7 +792,7 @@ async function reapRunWorkerProcesses({ events }) {
   return { reaped, skipped };
 }
 
-async function driveInitialScriptedManagedEpoch({
+async function driveScriptedManagedEpoch({
   runDir,
   repoRoot,
   request,
@@ -843,20 +804,22 @@ async function driveInitialScriptedManagedEpoch({
   sentinel = null,
   preDispatchBindings = null,
   drainEscalations = null,
+  escalateTerminalConflict = null,
+  preactivated = null,
 }) {
   let events = [...initialEvents];
   const { plan, manifests, executor_packets: packets } = committed.bundle;
   const controllerId = activation.controllerDescriptor.controller_id;
   const registrationDigest = activation.registration.registration_digest;
   const sessionNonceDigest = digestArtifact(activation.sessionNonce);
+  const preactivatedByPacket = new Map((preactivated?.armedLeases ?? []).map((lease) => [
+    lease.packet_digest,
+    lease,
+  ]));
   for (;;) {
     const frontier = computeReadyFrontier({ plan, events }).dispatchable;
     if (frontier.length === 0) break;
-    await managedSupervisor.barrierAll({
-      barrierId: `dispatch-${plan.plan_epoch}-${events.length}`,
-      reason: 'initial_scripted_dispatch',
-      frozenEventDigest: events.at(-1).event_digest,
-    });
+    const alreadyRunning = projectRuntimeState({ events }).running;
     const issuedControlDigest = controlEvents().at(-1)?.event_digest;
     if (typeof issuedControlDigest !== 'string') {
       throw new ManagedRuntimeError(
@@ -879,47 +842,63 @@ async function driveInitialScriptedManagedEpoch({
     }
     syncSentinelWatches({ sentinel, runningTodoIds: [...frontier],
       rootOf: (todoId) => worktreeByTodo.get(todoId) });
-    const stagedLeases = [];
-    for (const todoId of frontier) {
-      const packet = packets[todoId];
-      const staged = {
-        schema: 'lattice.runtime_write_lease.v1',
-        lease_id: `lease-${packet.packet_digest.slice(0, 24)}`,
-        run_id: request.request_id,
-        todo_id: todoId,
-        plan_epoch: plan.plan_epoch,
-        packet_digest: packet.packet_digest,
-        controller_registration_digest: registrationDigest,
-        supervisor_session_nonce_digest: sessionNonceDigest,
-        state: 'staged',
-        ttl_ms: 60_000,
-        issued_control_digest: issuedControlDigest,
-        lease_digest: '',
-      };
-      staged.lease_digest = selfDigest(staged, 'lease_digest');
-      await managedSupervisor.prepareController({
-        controllerId,
-        executorPacket: packet,
-        stagedLease: staged,
+    let activated = frontier.every((todoId) => preactivatedByPacket.has(packets[todoId].packet_digest))
+      ? { armedLeases: frontier.map((todoId) => {
+        const packetDigest = packets[todoId].packet_digest;
+        const lease = preactivatedByPacket.get(packetDigest);
+        preactivatedByPacket.delete(packetDigest);
+        return lease;
+      }) }
+      : null;
+    if (activated === null) {
+      await managedSupervisor.barrierAll({
+        barrierId: `dispatch-${plan.plan_epoch}-${events.length}`,
+        reason: 'scripted_dispatch',
+        frozenEventDigest: events.at(-1).event_digest,
+      });
+      const stagedLeases = [];
+      for (const todoId of frontier) {
+        const packet = packets[todoId];
+        const staged = {
+          schema: 'lattice.runtime_write_lease.v1',
+          lease_id: `lease-${packet.packet_digest.slice(0, 24)}`,
+          run_id: request.request_id,
+          todo_id: todoId,
+          plan_epoch: plan.plan_epoch,
+          packet_digest: packet.packet_digest,
+          controller_registration_digest: registrationDigest,
+          supervisor_session_nonce_digest: sessionNonceDigest,
+          state: 'staged',
+          ttl_ms: 60_000,
+          issued_control_digest: issuedControlDigest,
+          lease_digest: '',
+        };
+        staged.lease_digest = selfDigest(staged, 'lease_digest');
+        await managedSupervisor.prepareController({
+          controllerId,
+          executorPacket: packet,
+          stagedLease: staged,
+        });
+        stagedLeases.push(staged);
+      }
+      const activationDigest = digestArtifact({
+        schema: 'lattice.scripted_activation.v1',
+        committed_epoch_pointer_digest: committed.pointer.pointer_digest,
+        staged_lease_digests: stagedLeases.map((lease) => lease.lease_digest).sort(),
+      });
+      activated = await managedSupervisor.commitWriteGate({
+        planEpoch: plan.plan_epoch,
+        committedEpochDigest: committed.pointer.pointer_digest,
+        activationDigest,
+        commitReleaseBarrier: (barrier) => commitReleaseEpochBarrier({ runDir, barrier }),
+        committedAt: canonicalNow(),
       });
-      stagedLeases.push(staged);
     }
-    const activationDigest = digestArtifact({
-      schema: 'lattice.initial_scripted_activation.v1',
-      committed_epoch_pointer_digest: committed.pointer.pointer_digest,
-      staged_lease_digests: stagedLeases.map((lease) => lease.lease_digest).sort(),
-    });
-    const activated = await managedSupervisor.commitWriteGate({
-      planEpoch: plan.plan_epoch,
-      committedEpochDigest: committed.pointer.pointer_digest,
-      activationDigest,
-      commitReleaseBarrier: (barrier) => commitReleaseEpochBarrier({ runDir, barrier }),
-      committedAt: canonicalNow(),
-    });
     const armedByPacket = new Map(activated.armedLeases.map((lease) => [
       lease.packet_digest,
       lease,
     ]));
+    const terminalCheckpointByHandle = new Map();
     const managedAdapter = {
       async dispatch({ packet }) {
         const lease = armedByPacket.get(packet.packet_digest);
@@ -992,6 +971,17 @@ async function driveInitialScriptedManagedEpoch({
           controllerId,
           payloadDigest: response.observation.payload_digest,
         });
+        const binding = dispatch.payload?.direct_os_observation_binding;
+        if (typeof binding?.worktree_path !== 'string' || typeof binding?.base_sha !== 'string') {
+          throw new ManagedRuntimeError('ADAPTER_CONTROLLER_UNAVAILABLE',
+            `terminal diffのorigin bindingが無い: ${dispatch.subject.ref}`);
+        }
+        const checkpoint = await captureWorktreeDiff({
+          worktreePath: binding.worktree_path, baseSha: binding.base_sha,
+        });
+        // receiptのcheckpointはexecutor申告、これはsupervisorの独立観測でdigest schemaも異なる。
+        // 同じeventへ混ぜず、receipt記録後に別checkpointとして追記する。
+        terminalCheckpointByHandle.set(executorHandle, checkpoint);
         return { state: 'terminal', receipt };
       },
     };
@@ -1021,7 +1011,8 @@ async function driveInitialScriptedManagedEpoch({
     // **workerが走っている間だけが、実行時競合を掴める窓である。** 観測を1件ずつ待たずに
     // 回し、その合間に早期警報のescalationを捌く。捌くのは`replaceEventsAtomically`の
     // 直後だけ——そこでしかdiskとメモリのeventsが一致していない。
-    const awaiting = new Set(dispatched.dispatched);
+    const awaiting = new Set([...dispatched.dispatched, ...alreadyRunning]);
+    const completedReceiptIds = new Set();
     const observeDeadline = Date.now() + SCRIPTED_OBSERVE_TIMEOUT_MS;
     let frozen = false;
     while (awaiting.size > 0) {
@@ -1042,6 +1033,74 @@ async function driveInitialScriptedManagedEpoch({
         });
         if (observed.observation.state === 'running') continue;
         events = observed.events;
+        if (observed.observation.state === 'terminal') {
+          const dispatchForTerminal = events.findLast((event) => (
+            event.kind === 'executor_dispatched'
+            && event.subject?.kind === 'todo' && event.subject.ref === todoId
+          ));
+          const terminalCheckpoint = terminalCheckpointByHandle
+            .get(dispatchForTerminal.payload.executor_handle);
+          if (terminalCheckpoint === undefined) {
+            throw new ManagedRuntimeError('ADAPTER_CONTROLLER_UNAVAILABLE',
+              `terminal diffが保存されていない: ${todoId}`);
+          }
+          terminalCheckpointByHandle.delete(dispatchForTerminal.payload.executor_handle);
+          events.push(buildNextRunEvent({
+            events,
+            runId: request.request_id,
+            kind: 'checkpoint_observed',
+            planEpoch: plan.plan_epoch,
+            subject: { kind: 'todo', ref: todoId },
+            payload: { ...terminalCheckpoint, observed_by: 'supervisor_terminal' },
+            recordedAt: canonicalNow(),
+          }));
+          const recordedReceipt = events.findLast((event) => event.kind === 'receipt_recorded'
+            && event.subject?.kind === 'todo' && event.subject.ref === todoId);
+          completedReceiptIds.add(recordedReceipt.payload.receipt_id);
+          const terminalEvent = events.findLast((event) => event.kind === 'executor_terminal'
+            && event.subject?.kind === 'todo' && event.subject.ref === todoId);
+          const currentDispatch = events.findLast((event) => event.kind === 'executor_dispatched'
+            && event.subject?.kind === 'todo' && event.subject.ref === todoId
+            && event.sequence < terminalEvent.sequence);
+          const overlappingTodoIds = plan.nodes.map((node) => node.todo_id)
+            .filter((otherId) => {
+              if (otherId === todoId) return false;
+              const otherDispatch = events.findLast((event) => event.kind === 'executor_dispatched'
+                && event.subject?.kind === 'todo' && event.subject.ref === otherId
+                && event.sequence < terminalEvent.sequence);
+              if (otherDispatch === undefined) return false;
+              const otherTerminal = events.find((event) => event.kind === 'executor_terminal'
+                && event.subject?.kind === 'todo' && event.subject.ref === otherId
+                && event.sequence > otherDispatch.sequence);
+              return otherTerminal === undefined || otherTerminal.sequence > currentDispatch.sequence;
+            });
+          const relevantTodoIds = [todoId, ...overlappingTodoIds];
+          const terminalCheckpointEvent = events.findLast((event) => event.kind === 'checkpoint_observed'
+            && event.subject?.kind === 'todo' && event.subject.ref === todoId
+            && event.payload?.observed_by === 'supervisor_terminal');
+          const observations = [{ todo_id: todoId,
+            paths: terminalCheckpointEvent.payload.diff.entries.map((entry) => entry.path) }];
+          for (const peerId of overlappingTodoIds) {
+            const peerCheckpoint = events.findLast((event) => event.kind === 'checkpoint_observed'
+              && event.subject?.kind === 'todo' && event.subject.ref === peerId
+              && event.payload?.observed_by === 'supervisor_terminal');
+            if (peerCheckpoint !== undefined) observations.push({ todo_id: peerId,
+              paths: peerCheckpoint.payload.diff.entries.map((entry) => entry.path) });
+          }
+          const actionable = classifyObservedDiff({ plan, manifests, observations,
+            relevantTodoIds }).findings.filter((finding) => finding.kind === 'observed_write_conflict'
+              && finding.todo_ids.includes(todoId));
+          if (actionable.length > 0) {
+            if (typeof escalateTerminalConflict !== 'function') {
+              throw new ManagedRuntimeError('FINDING_UNRESOLVED',
+                'terminal conflictのmanaged escalation経路が無い');
+            }
+            await replaceEventsAtomically(runDir, events);
+            events = await escalateTerminalConflict({ finding: actionable[0],
+              checkpointDigest: terminalCheckpointEvent.payload.checkpoint_digest });
+            frozen = true;
+          }
+        }
         await replaceEventsAtomically(runDir, events);
         syncSentinelWatches({ sentinel, runningTodoIds: projectRuntimeState({ events }).running,
           rootOf: (id) => events.findLast((event) => event.kind === 'executor_dispatched'
@@ -1049,7 +1108,9 @@ async function driveInitialScriptedManagedEpoch({
             ?.payload?.direct_os_observation_binding?.worktree_path });
         awaiting.delete(todoId);
         progressed = true;
+        if (frozen) break;
       }
+      if (frozen) break;
       if (awaiting.size === 0) break;
       if (Date.now() >= observeDeadline) {
         throw new ManagedRuntimeError(
@@ -1061,8 +1122,8 @@ async function driveInitialScriptedManagedEpoch({
         await new Promise((resolve) => { setTimeout(resolve, SCRIPTED_OBSERVE_POLL_MS); });
       }
     }
-    // holdが掛かったらdispatchを進めない。freeze後のreceiptはstaleとして拒否されるので、
-    // 裁定へ進むと「受理されなかった」で落ちるだけである。
+    // holdが掛かったらdispatchを進めない。記録済みreceiptは失わず、対象群の再compile後に
+    // origin bindingとcarry witnessを満たすものだけを後続epochで裁定する。
     if (frozen) return events;
     const adjudicated = adjudicatePendingReceipts({
       runId: request.request_id,
@@ -1070,10 +1131,14 @@ async function driveInitialScriptedManagedEpoch({
       events,
       recordedAt: canonicalNow(),
     });
-    if (adjudicated.decisions.some((decision) => decision.decision !== 'accepted')) {
+    const rejectedCompleted = adjudicated.decisions.filter((decision) => (
+      completedReceiptIds.has(decision.receipt_id) && decision.decision !== 'accepted'
+    ));
+    if (rejectedCompleted.length > 0) {
       throw new ManagedRuntimeError(
         'ADAPTER_CONTROLLER_UNAVAILABLE',
-        'scripted controller receiptが受理されなかった',
+        `scripted controller receiptが受理されなかった: ${rejectedCompleted
+          .map((decision) => `${decision.receipt_id}:${decision.detail}`).join(',')}`,
       );
     }
     events = adjudicated.events;
@@ -2227,6 +2292,49 @@ export async function runManagedSupervisorDaemon({
     return current;
   };
 
+  const escalateTerminalConflict = async ({ finding, checkpointDigest }) => {
+    const activeEpoch = await readCommittedEpochStore(runDir);
+    const candidate = {
+      schema: 'lattice.runtime_finding_candidate.v1',
+      proposed_kind: finding.kind,
+      todo_ids: [...finding.todo_ids].sort(),
+      path: finding.path,
+      resource_id: null,
+      evidence_digests: [checkpointDigest],
+      candidate_digest: '',
+    };
+    candidate.candidate_digest = selfDigest(candidate, 'candidate_digest');
+    const submit = (operation, { artifact = null, artifactDigest = null,
+      checkpoint = null } = {}) => executeControl(createRuntimeControlRequest({
+      requestId: `terminal-${randomUUID()}-${operation.replace(/_/gu, '-')}`,
+      runId: request.request_id, operation, sessionNonce,
+      payload: controlOperationPayload({ operation, runRef: request.request_id,
+        artifact, artifactDigest, checkpointDigest: checkpoint,
+        expectedEpoch: activeEpoch.pointer.plan_epoch,
+        expectedQueueDigest: null }),
+    }));
+    const recorded = await submit('finding_record', {
+      artifact: candidate, artifactDigest: digestArtifact(candidate),
+      checkpoint: checkpointDigest,
+    });
+    if (recorded.outcome !== 'completed') {
+      throw new ManagedRuntimeError('FINDING_UNRESOLVED',
+        'terminal findingを耐久化できない');
+    }
+    const findingDigest = recorded.result.finding_digest;
+    const conflicted = await submit('conflict', { artifactDigest: findingDigest });
+    if (conflicted.outcome !== 'completed') {
+      throw new ManagedRuntimeError('FINDING_UNRESOLVED',
+        'terminal findingをfreezeへ運べない');
+    }
+    const held = await submit('hold');
+    if (held.outcome !== 'completed') {
+      throw new ManagedRuntimeError('HOLD_ACKS_INCOMPLETE',
+        'terminal conflictの対象barrierが完了しない');
+    }
+    return readBoundedJson(path.join(runDir, 'events.json'), 'run events');
+  };
+
   /** 警報の処理を直列化する鎖。`onWarning`はここへ繋ぐだけにする。 */
   let escalationChain = Promise.resolve();
 
@@ -2366,7 +2474,7 @@ export async function runManagedSupervisorDaemon({
           });
           epochDriveActive = true;
           try {
-            await driveInitialScriptedManagedEpoch({
+            await driveScriptedManagedEpoch({
               runDir,
               repoRoot,
               request,
@@ -2378,6 +2486,7 @@ export async function runManagedSupervisorDaemon({
               controlEvents: () => controlEvents,
               preDispatchBindings,
               drainEscalations: drainPendingEscalations,
+              escalateTerminalConflict,
             });
           } finally {
             epochDriveActive = false;
@@ -2488,10 +2597,11 @@ export async function runManagedSupervisorDaemon({
           const verified = independentlyClassified.find((findingValue) => findingValue.kind === candidate.proposed_kind
             && findingValue.path === candidate.path
             && canonicalizeArtifact(findingValue.todo_ids) === canonicalizeArtifact(candidate.todo_ids));
-          if (match === undefined || verified === undefined) throw new ManagedRuntimeError(
+          const terminalSupervisorObservation = observed.payload?.observed_by === 'supervisor_terminal';
+          if ((!terminalSupervisorObservation && match === undefined) || verified === undefined) throw new ManagedRuntimeError(
             'FINDING_UNRESOLVED', 'path findingのproducer/verifier再導出が一致しない');
-          derivedTodoIds = [...match.todo_ids];
-          derivedKind = match.kind;
+          derivedTodoIds = [...(match ?? verified).todo_ids];
+          derivedKind = (match ?? verified).kind;
         } else {
           const match = independentlyClassified.find((findingValue) => findingValue.kind === candidate.proposed_kind
             && findingValue.resource_id === candidate.resource_id
@@ -2603,6 +2713,9 @@ export async function runManagedSupervisorDaemon({
         let events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
         const conflict = events.findLast((event) => event.kind === 'conflict_found');
         if (!conflict) throw new ManagedRuntimeError('FINDING_UNRESOLVED', '保存済みconflictなし');
+        const active = await readCommittedEpochStore(runDir);
+        const holdTodoIds = affectedTodoIds(active.bundle.plan, active.bundle.manifests,
+          conflict.payload.todo_ids);
         const holdBarrierId = `barrier-${randomUUID()}`;
         const holdRecordedAt = canonicalNow();
         await appendControl({ run_id: request.request_id, kind: 'hold_prepared',
@@ -2615,7 +2728,7 @@ export async function runManagedSupervisorDaemon({
         const held = await managedSupervisor.holdConflict({
           findingDigest: conflict.payload.finding_digest, frozenEventDigest: events.at(-1).event_digest,
           barrierId: holdBarrierId, reason: conflict.payload.kind,
-          recordedAt: holdRecordedAt,
+          recordedAt: holdRecordedAt, todoIds: holdTodoIds,
         });
         controlEvents = await eventStore.readEvents();
         const quiesced = controlEvents.filter((event) => event.kind === 'executor_quiesced'
@@ -2629,7 +2742,6 @@ export async function runManagedSupervisorDaemon({
               barrier_evidence_digest: evidence.payload.evidence_digest },
             recordedAt: holdRecordedAt }));
         }
-        const active = await readCommittedEpochStore(runDir);
         const decided = decideHoldAndCarryOver({ runId: request.request_id,
           request: active.bundle.request, plan: active.bundle.plan,
           manifests: active.bundle.manifests, packets: active.bundle.executor_packets,
@@ -3018,39 +3130,11 @@ export async function runManagedSupervisorDaemon({
           lease.lease_digest = selfDigest(lease, 'lease_digest');
           return lease;
         };
-        const rebound = new Set(Object.keys(rebindPackets));
-        const rebindEvidence = new Map();
         const preparedSuccessors = new Set();
-        for (const [todoId, packet] of Object.entries(rebindPackets)) {
-          const owner = controllerForTodo(todoId);
-          const dispatch = projectRuntimeState({ events }).dispatches[todoId];
-          const evidence = await managedSupervisor.rebindController({ controllerId: owner.controllerDescriptor.controller_id, rebindPacket: packet,
-            stagedLease: stagedLease(todoId, packet.packet_digest, owner), expected: { todo_id: todoId,
-              executor_handle: dispatch.payload.executor_handle, worktree_id: dispatch.payload.worktree_id,
-              predecessor_packet_digest: active.bundle.executor_packets[todoId].packet_digest,
-              rebind_packet_digest: packet.packet_digest } });
-          rebindEvidence.set(todoId, { ...evidence,
-            controller_registration_digest: owner.registration.registration_digest });
-        }
-        // **ここが再開の位置である。** rebindは静止を要求する（`write_enabled === false`）ので、
-        // holdの直後に再開すると後継epochへ束ね直せない。carry-overは「作業を捨てない」で
-        // あって「一度も止まらない」ではない——barrierで止まり、rebindで新epochへ繋がれ、
-        // そこで初めて動き出す。
-        if (rebound.size > 0) {
-          const resumed = await resumeContinuedWorkers({ events, todoIds: [...rebound] });
-          if (resumed.resumed.length > 0 || resumed.skipped.length > 0) {
-            await appendControl({ run_id: request.request_id, kind: 'workers_resumed',
-              session_nonce_digest: digestArtifact(sessionNonce), payload: {
-                resumed_todo_ids: [...resumed.resumed].sort(),
-                skipped_count: resumed.skipped.length,
-              } });
-          }
-        }
         for (const todoId of core.planDiff.redispatched) {
           const successors = recompileRequest.task_migration.entries
             .find((entry) => entry.predecessor_task_id === todoId)?.successor_task_ids ?? [];
           for (const successorId of successors) {
-            if (rebound.has(successorId)) continue;
             const packet = executorPackets[successorId];
             const owner = controllerForTodo(successorId);
             if (packet !== undefined) await managedSupervisor.prepareController({
@@ -3064,36 +3148,13 @@ export async function runManagedSupervisorDaemon({
           .filter((receipt) => receipt.accepted_sequence !== null
             && acceptedCheckpointDigests.has(receipt.payload?.checkpoint_digest))
           .map((receipt) => receipt.todo_id));
+        const carriedTodoIds = new Set(planDiff.carried_over);
         const expectedLiveTodoIds = newPlan.nodes.map((node) => node.todo_id)
-          .filter((todoId) => !acceptedTodoIds.has(todoId)).sort();
-        const activatedTodoIds = [...new Set([...rebound, ...preparedSuccessors])].sort();
+          .filter((todoId) => !acceptedTodoIds.has(todoId) && !carriedTodoIds.has(todoId)).sort();
+        const activatedTodoIds = [...preparedSuccessors].sort();
         if (canonicalizeArtifact(expectedLiveTodoIds) !== canonicalizeArtifact(activatedTodoIds)) {
           throw new ManagedRuntimeError('EPOCH_REBIND_INCOMPLETE', 'successor live taskのrebind/prepare集合が完全でない');
         }
-        // 全direct ack後だけepoch_reboundをexact-once batchで保存する。
-        const reboundRecordedAt = canonicalNow();
-        const proposedReboundBatch = [];
-        let proposedReboundEvents = [...events];
-        for (const [todoId, packet] of Object.entries(rebindPackets)
-          .sort(([left], [right]) => left.localeCompare(right))) {
-          const event = buildNextRunEvent({ events: proposedReboundEvents,
-            runId: active.meta.run_id, kind: 'epoch_rebound', planEpoch: nextEpoch,
-            subject: { kind: 'todo', ref: todoId }, payload: { ...packet,
-              rebind_ack_digest: rebindEvidence.get(todoId).ack.ack_digest,
-              control_event_digest: rebindEvidence.get(todoId).control_event_digest,
-              controller_registration_digest: rebindEvidence.get(todoId).controller_registration_digest },
-            recordedAt: reboundRecordedAt });
-          proposedReboundEvents.push(event);
-          proposedReboundBatch.push(event);
-        }
-        events = await publishRuntimeEventBatch({ runDir,
-          transactionId: recompileRequest.request_id, phase: 'epoch_rebound', planEpoch: nextEpoch,
-          bindingDigest: digestArtifact({ successor_epoch: nextEpoch,
-            successor_bundle_digest: staged.bundle_digest,
-            ordered_rebind_packet_digests: Object.entries(rebindPackets)
-              .sort(([left], [right]) => left.localeCompare(right))
-              .map(([, packet]) => packet.packet_digest) }),
-          currentEvents: events, proposedBatch: proposedReboundBatch, crashInjector });
         controlEvents = await eventStore.readEvents();
         const committed = await commitStagedSuccessorEpoch({ runDir,
           transactionId: staged.transaction_id,
@@ -3137,6 +3198,29 @@ export async function runManagedSupervisorDaemon({
           request_id: controlRequest.request_id, gate_digest: activated.gate.gate_digest,
           event_digest: events.at(-1).event_digest,
         });
+        if (recompileRequest.mode === 'intentional_serial'
+          && isDistributedScriptedControllerActivation(activation)) {
+          epochDriveActive = true;
+          try {
+            events = await driveScriptedManagedEpoch({
+              runDir,
+              repoRoot,
+              request: committed.bundle.request,
+              committed,
+              activation,
+              managedSupervisor,
+              initialEvents: events,
+              controlEvents: () => controlEvents,
+              sentinel,
+              preDispatchBindings,
+              drainEscalations: drainPendingEscalations,
+              escalateTerminalConflict,
+              preactivated: activated,
+            });
+          } finally {
+            epochDriveActive = false;
+          }
+        }
         const result = buildControlResult({ operation: 'recompile', outcome: 'recompiled',
           eventHeadDigest: events.at(-1).event_digest,
           controlHeadDigest: (await eventStore.readEvents()).at(-1).event_digest,

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