@quolu/lattice 0.46.2 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.46.2",
+  "version": "0.47.0",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",

package/src/artifact-contracts.mjs

@@ -111,9 +111,6 @@ function inspectArray(value, state, depth) {
   if (Object.getPrototypeOf(value) !== Array.prototype) {
     invalidArtifact('array prototypeが不正');
   }
-  if (value.length > MAX_COLLECTION_ITEMS) {
-    invalidArtifact('array item数が上限を超えている');
-  }
 
   const ownKeys = Reflect.ownKeys(value);
   if (ownKeys.some((key) => typeof key !== 'string')) {

package/src/project-cli.mjs

@@ -275,7 +275,17 @@ async function resolveProjectState({ cwd, cliVersion }) {
       : todo.next_ready.length > 0
         ? { command: `lattice todo start --plan ${todo.next_ready[0].plan_key} --task ${todo.next_ready[0].task_id}${todo.next_ready.length > 1 ? ' --parallel-frontier' : ''}`,
           reason: todo.next_ready.length > 1 ? 'parallel_frontier_present' : 'next_ready_present' }
-        : { command: 'lattice todo status', reason: 'no_ready_task' };
+        // 監査待ちが在る限り「残作業なし」と答えない。優先順位はactive_run > next_ready >
+        // audit_pending > なしで、ready frontierが在る間はADR 0063の並列開始コマンドが勝つ
+        // ——ここを監査で上書きするとdispatchが再直列化する。監査待ちはtodo statusの
+        // audit_pending欄に常在するので、順位を下げても消えない。
+        // commandはverbatim実行可能で読み取り専用のものにする。`phase review`は
+        // `--reason <text>`のplaceholderを含みjournalを書き換えるので置かない
+        // （`todo phase status`の結果には既に両分岐のguidanceが載っている）。
+        : todo.audit_pending.length > 0
+          ? { command: `lattice todo phase status --plan ${todo.audit_pending[0].plan_key}`,
+            reason: 'audit_pending' }
+          : { command: 'lattice todo status', reason: 'no_ready_task' };
     const result = statusResult({
       cli: { available: true, version: cliVersion },
       project: { root: repoRoot, git_head: gitHead(repoRoot), project_id: store.project_id },
@@ -334,7 +344,7 @@ export async function runSessionContext({ cwd, stdout, cliVersion }) {
     schema: SESSION_CONTEXT_SCHEMA,
     // project discoveryの答えをそのまま埋める。hostは既存の検証器を再利用できる。
     status: state.result,
-    // todoは`todo_status_result.v4`そのもの。新しい意味論を発明しない。
+    // todoは`lattice todo status`のresultそのもの。新しい意味論を発明しない。
     todo: state.todo,
     independence,
     result_digest: '',

package/src/rc3-scripted-campaign.mjs

@@ -467,31 +467,30 @@ async function runScopeViolation({ scaffold }) {
     runId, plan, events, packets, todoId: 'TA', detect: detectCheckpointFindings, recordedAt: RUN_TIMESTAMP,
   });
   events = classified.events;
-  const held = decideHoldAndCarryOver({
-    runId, request, plan, manifests, packets, events, recordedAt: RUN_TIMESTAMP,
-  });
-  events = held.events;
+  events = await driveToClose({ runId, plan, events, packets, manifests, adapter });
+  const state = projectRuntimeState({ events });
   return {
     request,
     plan,
     manifests,
-    holdDecision: held.holdDecision,
     events,
     record: conditionRecord({
       condition: 'scope_violation',
-      // offenderとそのaffected closure（ここではTAのみ）をhold。closure外のTBは
-      // witnessを実証してcontinueする（plan条件表「offenderとaffected closure hold」）。
+      // directory名はRC3 artifact互換のため維持する。現契約では単独の予測超過は
+      // conflictではなく、観測を残したまま有効なreceiptを受理する。
       expected: {
-        finding_kinds: ['undeclared_write'],
-        hold_includes_offender: true,
-        hold: ['TA'],
-        continue: ['TB'],
+        observation_kinds: ['prediction_excess'],
+        conflict_finding_kinds: [],
+        frozen: false,
+        accepted: ['TA', 'TB'],
+        closed: true,
       },
       actual: {
-        finding_kinds: [...new Set(classified.findings.map(({ kind }) => kind))],
-        hold_includes_offender: held.holdDecision.hold_set.includes('TA'),
-        hold: held.holdDecision.hold_set,
-        continue: held.holdDecision.continue_set,
+        observation_kinds: [...new Set(classified.observations.map(({ kind }) => kind))],
+        conflict_finding_kinds: [...new Set(classified.findings.map(({ kind }) => kind))],
+        frozen: state.freeze !== null,
+        accepted: state.accepted,
+        closed: state.closed,
       },
       events,
       plan,
@@ -1334,7 +1333,7 @@ export async function runRc3ScriptedCampaign(options = {}) {
   const clean = await timed('clean_parallel', () => runCleanParallel({ scaffold }));
   const late = await timed('late_path_conflict', () => runLateConflict({ scaffold }));
   // 条件名`scope_violation`はRC3 manifestのdirectory名として凍結されているので動かさない。
-  // 中で期待するfinding種別だけが製品に追従して`undeclared_write`になる。
+  // 中では単独の予測超過を観測し、conflictへ昇格しない現契約を検証する。
   const scope = await timed('scope_violation', () => runScopeViolation({ scaffold }));
   const semantic = await timed('semantic_unknown', () => runSemanticUnknown({ scaffold }));
   const stale = await timed('stale_receipt', () => runStaleReceipt({ scaffold }));

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,