@quolu/lattice 0.31.0 → 0.33.0

package/src/runtime-cli.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { constants as fsConstants } from 'node:fs';
 import {
   lstat,
@@ -139,6 +139,20 @@ const KNOWN_ADAPTERS = Object.freeze(['scripted', 'isolated-worktree', 'actual-a
  * 超えたら`rejected`として理由ごとjournalへ残す（黙って見送らない）。
  */
 const IO_ESCALATION_LOCK_TIMEOUT_MS = 15_000;
+/**
+ * 係争pathから資源idを導出する（front-endと同じ形）。
+ *
+ * front-endは`owns`から`own-<kind>-<sha256(target)先頭16>`を作る。path競合の直列化資源は
+ * その形でなければ、後継planの競合辺が実ownershipの資源と別物になってしまう。
+ * **形を1箇所で決める。** 別の形で作ると、同じpathが別の資源に見える。
+ */
+function ownedResourceId(kind, target) {
+  return `own-${kind}-${createHash('sha256').update(target, 'utf8').digest('hex').slice(0, 16)}`;
+}
+
+function ownedPathResourceId(pathValue) {
+  return ownedResourceId('path', pathValue);
+}
 /** 走行中workerの完了を待つ上限と間隔。待てないと走行中の観測が成立しない。 */
 const SCRIPTED_OBSERVE_TIMEOUT_MS = 120_000;
 const SCRIPTED_OBSERVE_POLL_MS = 20;
@@ -743,6 +757,80 @@ 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を、耐久記録から回収する。
+ *
+ * **記録が正本である。** 誰を起こしたかは`executor_dispatched`の
+ * `direct_os_observation_binding`が持っており、controllerが落ちていても残る。
+ *
+ * pidだけで殺さない。pidは再利用されるので、start identityを取り直して記録と一致した
+ * ものだけを止める——一致しなければ、それは別のprocessである。
+ *
+ * SIGKILLで送る。holdで止めたworkerはSIGSTOP状態にあり、SIGTERMは継続されるまで
+ * 配送されない。停止したまま放置されたprocessは自分では終われない。
+ */
+async function reapRunWorkerProcesses({ events }) {
+  const reaped = [];
+  const skipped = [];
+  const seen = new Set();
+  for (const event of events) {
+    if (event.kind !== 'executor_dispatched') continue;
+    const binding = event.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' || seen.has(pid)) continue;
+    seen.add(pid);
+    const observed = await observeManagedProcessStartIdentity(pid).catch(() => null);
+    if (observed === null) continue; // 既に居ない
+    if (observed.identity_digest !== recorded) {
+      skipped.push({ pid, reason: 'start identity不一致（pid再利用）' });
+      continue;
+    }
+    try { process.kill(pid, 'SIGKILL'); reaped.push(pid); } catch { /* 競合で既に消えた */ }
+  }
+  return { reaped, skipped };
+}
+
 async function driveInitialScriptedManagedEpoch({
   runDir,
   repoRoot,
@@ -754,13 +842,13 @@ async function driveInitialScriptedManagedEpoch({
   controlEvents,
   sentinel = null,
   preDispatchBindings = null,
+  drainEscalations = 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 processGroupId = activation.childPid;
   for (;;) {
     const frontier = computeReadyFrontier({ plan, events }).dispatchable;
     if (frontier.length === 0) break;
@@ -862,12 +950,19 @@ async function driveInitialScriptedManagedEpoch({
           controller_session_nonce_digest:
             activation.controllerDescriptor.controller_session_nonce_digest,
           direct_os_observation_binding: {
-            process_pid: activation.childPid,
-            process_group_id: processGroupId,
+            // **controllerではなくworker processを指す。** holdは静止の証明を要求し、
+            // 直接OS観測はここで名指しされたprocessが実際に停止していることを確かめる。
+            // controllerを指していた頃は、止めれば応答できず止めなければ証明できなかった。
+            process_pid: response.worker_process.pid,
+            process_group_id: response.worker_process.process_group_id,
             process_start_identity:
-              structuredClone(activation.controllerDescriptor.process_start_identity),
+              structuredClone(response.worker_process.process_start_identity),
+            // workerはさらに子を持たない。空配列は「子が居ない」という主張であり、
+            // 直接OS観測は実測と突き合わせて未記録のchildが居ないことまで確かめる。
+            process_children: [],
             // TODOごとの木を指す。ここがrepo rootだった頃、帰属はrootから決まらなかった。
             worktree_path: worktreeByTodo.get(packet.todo_id),
+            worktree_realpath: worktreeByTodo.get(packet.todo_id),
             base_sha: packet.base_sha,
           },
         };
@@ -877,37 +972,27 @@ async function driveInitialScriptedManagedEpoch({
           event.kind === 'executor_dispatched'
           && event.payload?.executor_handle === executorHandle
         ));
-        // workerはdispatchで終わらない。走り続けている間はrunningが返るので、
-        // 完了まで待つ。ここが待てないと、走行中の観測が成立する構成を持てない。
-        const deadline = Date.now() + SCRIPTED_OBSERVE_TIMEOUT_MS;
-        for (;;) {
-          const response = await managedSupervisor.route('observe', controllerId, {
-            executor_handle: executorHandle,
-            expected_epoch: dispatch.plan_epoch,
-            expected_lease_digest: dispatch.payload.write_lease_digest,
-          });
-          if (response.observation.state === 'terminal') {
-            const receipt = await readScriptedControllerReceipt({
-              runDir,
-              controllerId,
-              payloadDigest: response.observation.payload_digest,
-            });
-            return { state: 'terminal', receipt };
-          }
-          if (response.observation.state !== 'running') {
-            throw new ManagedRuntimeError(
-              'ADAPTER_CONTROLLER_UNAVAILABLE',
-              `scripted controllerが未知のstateを返した: ${response.observation.state}`,
-            );
-          }
-          if (Date.now() >= deadline) {
-            throw new ManagedRuntimeError(
-              'ADAPTER_CONTROLLER_UNAVAILABLE',
-              `scripted workerが時間内に終わらない: ${executorHandle}`,
-            );
-          }
-          await new Promise((resolve) => { setTimeout(resolve, SCRIPTED_OBSERVE_POLL_MS); });
+        // **ここでpollしない。** 待つのは駆動側の仕事である——workerが走っている間が
+        // 実行時競合を掴める唯一の窓であり、その窓は駆動側がeventsを手元に持っている時
+        // にしか安全に触れない。ここで待つと、窓の間ずっと駆動側が止まる。
+        const response = await managedSupervisor.route('observe', controllerId, {
+          executor_handle: executorHandle,
+          expected_epoch: dispatch.plan_epoch,
+          expected_lease_digest: dispatch.payload.write_lease_digest,
+        });
+        if (response.observation.state === 'running') return { state: 'running' };
+        if (response.observation.state !== 'terminal') {
+          throw new ManagedRuntimeError(
+            'ADAPTER_CONTROLLER_UNAVAILABLE',
+            `scripted controllerが未知のstateを返した: ${response.observation.state}`,
+          );
         }
+        const receipt = await readScriptedControllerReceipt({
+          runDir,
+          controllerId,
+          payloadDigest: response.observation.payload_digest,
+        });
+        return { state: 'terminal', receipt };
       },
     };
     const dispatched = await dispatchReadyFrontier({
@@ -933,22 +1018,52 @@ async function driveInitialScriptedManagedEpoch({
       rootOf: (todoId) => events.findLast((event) => event.kind === 'executor_dispatched'
         && event.subject?.kind === 'todo' && event.subject.ref === todoId)
         ?.payload?.direct_os_observation_binding?.worktree_path });
-    for (const todoId of dispatched.dispatched) {
-      const observed = await observeExecutor({
-        runId: request.request_id,
-        todoId,
-        plan,
-        events,
-        adapter: managedAdapter,
-        recordedAt: canonicalNow(),
-      });
-      events = observed.events;
-      await replaceEventsAtomically(runDir, events);
-      syncSentinelWatches({ sentinel, runningTodoIds: projectRuntimeState({ events }).running,
-        rootOf: (todoId) => events.findLast((event) => event.kind === 'executor_dispatched'
-          && event.subject?.kind === 'todo' && event.subject.ref === todoId)
-          ?.payload?.direct_os_observation_binding?.worktree_path });
+    // **workerが走っている間だけが、実行時競合を掴める窓である。** 観測を1件ずつ待たずに
+    // 回し、その合間に早期警報のescalationを捌く。捌くのは`replaceEventsAtomically`の
+    // 直後だけ——そこでしかdiskとメモリのeventsが一致していない。
+    const awaiting = new Set(dispatched.dispatched);
+    const observeDeadline = Date.now() + SCRIPTED_OBSERVE_TIMEOUT_MS;
+    let frozen = false;
+    while (awaiting.size > 0) {
+      const drained = await drainEscalations?.(events) ?? null;
+      if (drained !== null) {
+        events = drained;
+        if (projectRuntimeState({ events }).freeze !== null) { frozen = true; break; }
+      }
+      let progressed = false;
+      for (const todoId of [...awaiting]) {
+        const observed = await observeExecutor({
+          runId: request.request_id,
+          todoId,
+          plan,
+          events,
+          adapter: managedAdapter,
+          recordedAt: canonicalNow(),
+        });
+        if (observed.observation.state === 'running') continue;
+        events = observed.events;
+        await replaceEventsAtomically(runDir, events);
+        syncSentinelWatches({ sentinel, runningTodoIds: projectRuntimeState({ events }).running,
+          rootOf: (id) => events.findLast((event) => event.kind === 'executor_dispatched'
+            && event.subject?.kind === 'todo' && event.subject.ref === id)
+            ?.payload?.direct_os_observation_binding?.worktree_path });
+        awaiting.delete(todoId);
+        progressed = true;
+      }
+      if (awaiting.size === 0) break;
+      if (Date.now() >= observeDeadline) {
+        throw new ManagedRuntimeError(
+          'ADAPTER_CONTROLLER_UNAVAILABLE',
+          `scripted workerが時間内に終わらない: ${[...awaiting].join(',')}`,
+        );
+      }
+      if (!progressed) {
+        await new Promise((resolve) => { setTimeout(resolve, SCRIPTED_OBSERVE_POLL_MS); });
+      }
     }
+    // holdが掛かったらdispatchを進めない。freeze後のreceiptはstaleとして拒否されるので、
+    // 裁定へ進むと「受理されなかった」で落ちるだけである。
+    if (frozen) return events;
     const adjudicated = adjudicatePendingReceipts({
       runId: request.request_id,
       plan,
@@ -1103,6 +1218,64 @@ async function runSeamResolve({ runDir, repoRoot, findingDigest, requestPath, st
   return resolution.lane === 'seam_transform' ? 0 : 1;
 }
 
+/**
+ * 切断コストの内訳を、記録済みfindingについて投影する（read-only、docs/plan_seam-cost.md）。
+ *
+ * `seam resolve`が隔離worktreeで実変換まで行うのに対し、これは**変換を試す前の安い観測**である。
+ * 「何を共有しているから単純に切れないのか」を数えられる事実として返し、試すかどうかの判断は
+ * 操作するAIに残す。閾値も可否判定も返さない。投影であって記録ではないので、runへ何も書かない。
+ *
+ * symbolの帰属（concern_symbols）は入力で受ける。実行時のwitnessはpath単位の宣言しか持たず、
+ * 係争fileの中で誰がどのsymbolを触るかはAIだけが知っている——ここで推定しない。
+ */
+async function runSeamProfile({ runDir, repoRoot, findingDigest, inputPath, stdout }) {
+  const committed = await readCommittedEpochStore(runDir);
+  if (committed === null) {
+    throw new CliContractError('RUN_NOT_MANAGED', 'runがmanaged storeへactivateされていない');
+  }
+  const found = await readRuntimeFindingRecord({
+    runDir, findingDigest, planEpoch: committed.pointer.plan_epoch,
+  });
+  if (found.record === null) throw new CliContractError('STALE_FINDING', found.reason);
+  const finding = found.record.finding;
+  if (typeof finding.path !== 'string') {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE',
+      'path findingではない競合に切断コストの内訳は立たない');
+  }
+
+  const declaration = await readBoundedJson(inputPath, 'seam profile input');
+  const identifier = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/u;
+  const symbols = declaration?.concern_symbols;
+  const todoIds = [...finding.todo_ids].sort();
+  const declaredIds = symbols === null || typeof symbols !== 'object' || Array.isArray(symbols)
+    ? null : Object.keys(symbols).sort();
+  if (declaredIds === null
+    || declaredIds.join('\0') !== todoIds.join('\0')
+    || declaredIds.some((todoId) => !Array.isArray(symbols[todoId])
+      || symbols[todoId].length === 0
+      || !symbols[todoId].every((name) => identifier.test(name)))) {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE',
+      'concern_symbolsがfindingのtodo集合と一致しない。'
+      + `{"concern_symbols": {${todoIds.map((id) => `"${id}": ["<symbol>"]`).join(', ')}}}の形で渡す`);
+  }
+
+  let sourceText;
+  try {
+    sourceText = await readFile(path.join(repoRoot, finding.path), 'utf8');
+  } catch {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE', `係争fileを読めない: ${finding.path}`);
+  }
+  const { computeSeamCostProfile } = await import('./seam-cost.mjs');
+  const { profile, reasons } = await computeSeamCostProfile({
+    repoRoot, sourcePath: finding.path, sourceText, ownedSymbolsByTask: symbols,
+  });
+  if (profile === null) {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE', reasons.join(',') || 'profile_unavailable');
+  }
+  stdout.write(`${JSON.stringify(profile)}\n`);
+  return 0;
+}
+
 async function runObserve({ runDir, stdout }) {
   const { events } = await readRunStore(runDir);
   const chain = verifyRunEventChain({ events });
@@ -1152,7 +1325,9 @@ async function runStatus({ runDir, stdout }) {
   if (managed !== null) {
     output.schema = 'lattice.managed_run_status.v1';
     const runtimeProjection = {
-      schema: 'lattice.runtime_status_projection.v1',
+      // v2は`treatment_advice`の追加。既定modeが直列化でも変換を試せる場合があることを、
+      // 運転側が見える形にした（ct-003）。
+      schema: 'lattice.runtime_status_projection.v2',
       ...projectRuntimeStatusOverlays({ events }),
       runtime_frozen: managedFrozen,
     };
@@ -1810,6 +1985,13 @@ export async function runManagedSupervisorDaemon({
    * 「両方が書いた」と読めてしまう。これをholdへ繋ぐと、無実のTODOを止める。
    * 帰属が立たないならescalationへ進めない。警報と実在の記録はそのまま残す。
    */
+  /**
+   * holdが要求する静止を、この構成で証明できるか。
+   *
+   * 直接OS観測はexecutorのprocessが停止していることを実測する。scripted controllerは
+   * 自分のprocessで作業するので、そのprocessを止めると制御そのものが止まる——止めない限り
+   * 証明できず、止めれば応答できない。**別processのexecutorを持つまでこの穴は埋まらない。**
+   */
   const attributionIsDistinct = (warning, roots) => {
     const paths = warning.todo_ids.map((todoId) => roots[todoId]);
     if (paths.some((value) => typeof value !== 'string')) return false;
@@ -1853,17 +2035,7 @@ export async function runManagedSupervisorDaemon({
    *
    * @returns {{ok: true, expected_epoch: number}|{ok: false, outcome: string, detail: string}}
    */
-  const durablyRecordProbeCheckpoints = async (escalation, checkpointsByTodo) => {
-    let lock;
-    try {
-      lock = await acquireRuntimeLifecycleLock({ runDir,
-        sessionNonceDigest: digestArtifact(sessionNonce), operation: 'finding_record',
-        requestId: `${escalation.escalation_id}.checkpoint`,
-        timeoutMs: IO_ESCALATION_LOCK_TIMEOUT_MS, retryIntervalMs: 25 });
-    } catch (error) {
-      return { ok: false, outcome: 'rejected',
-        detail: `lifecycle lockを取れない: ${error?.code ?? 'RUN_BUSY'}` };
-    }
+  const recordProbeCheckpointsUnlocked = async (escalation, checkpointsByTodo) => {
     try {
       const active = await readCommittedEpochStore(runDir);
       if (active === null) return { ok: false, outcome: 'skipped', detail: 'managed epochが未commit' };
@@ -1894,6 +2066,23 @@ export async function runManagedSupervisorDaemon({
     } catch (error) {
       return { ok: false, outcome: 'rejected',
         detail: `probe checkpointを耐久化できない: ${error?.code ?? String(error?.message ?? error)}` };
+    }
+  };
+
+  /** lifecycle lockを自分で取ってから耐久化する版（epoch駆動の外から呼ぶ時）。 */
+  const durablyRecordProbeCheckpoints = async (escalation, checkpointsByTodo) => {
+    let lock;
+    try {
+      lock = await acquireRuntimeLifecycleLock({ runDir,
+        sessionNonceDigest: digestArtifact(sessionNonce), operation: 'finding_record',
+        requestId: `${escalation.escalation_id}.checkpoint`,
+        timeoutMs: IO_ESCALATION_LOCK_TIMEOUT_MS, retryIntervalMs: 25 });
+    } catch (error) {
+      return { ok: false, outcome: 'rejected',
+        detail: `lifecycle lockを取れない: ${error?.code ?? 'RUN_BUSY'}` };
+    }
+    try {
+      return await recordProbeCheckpointsUnlocked(escalation, checkpointsByTodo);
     } finally {
       await lock.release();
     }
@@ -1909,7 +2098,10 @@ export async function runManagedSupervisorDaemon({
    *
    * 途中で断られたらそこで止め、理由をjournalへ残す。静かに別経路へ逃げない。
    */
-  const escalateIoWarning = async (warning, probed, packets) => {
+  const escalateIoWarning = async (warning, probed, packets, options = {}) => {
+    // 耐久化と送信の経路だけを差し替える。判断そのものはどちらの文脈でも同一にする——
+    // 分けると「epoch駆動の中と外で違う止め方をする」ことになり、記録が読めなくなる。
+    const { recordCheckpoints = durablyRecordProbeCheckpoints, dispatchControl = null } = options;
     const built = buildIoEscalation({ warning, probe: probed,
       checkpointsByTodo: probed.checkpoints, packets });
     if (built === null) return null;
@@ -1928,7 +2120,7 @@ export async function runManagedSupervisorDaemon({
       return decide('skipped',
         'worktree rootを共有する構成では書き手を特定できない（帰属はrootだけで決まる）');
     }
-    const recorded = await durablyRecordProbeCheckpoints(escalation, probed.checkpoints);
+    const recorded = await recordCheckpoints(escalation, probed.checkpoints);
     if (!recorded.ok) return decide(recorded.outcome, recorded.detail);
 
     const submit = async (operation, { artifact = null, artifactDigest = null,
@@ -1940,13 +2132,15 @@ export async function runManagedSupervisorDaemon({
           artifact, artifactDigest, checkpointDigest,
           expectedEpoch: recorded.expected_epoch, expectedQueueDigest: null }),
       });
-      return handler(controlRequest);
+      return dispatchControl === null ? handler(controlRequest) : dispatchControl(controlRequest);
     };
     const unmetOf = (response) => (response?.result?.unmet ?? []).join('/')
       || String(response?.outcome ?? 'unknown');
 
     const findingResponse = await submit('finding_record', {
-      artifact: escalation.candidate, artifactDigest: escalation.candidate.candidate_digest,
+      // control operationが要求するのはartifact全体のdigestである。`candidate_digest`は
+      // 自分の欄を除いた自己digestなので、そのまま渡すとbindingが合わず必ず弾かれる。
+      artifact: escalation.candidate, artifactDigest: digestArtifact(escalation.candidate),
       checkpointDigest: escalation.checkpoint_digest,
     }).catch((error) => ({ outcome: 'rejected',
       result: { unmet: [String(error?.code ?? error?.message ?? error)] } }));
@@ -1970,6 +2164,17 @@ export async function runManagedSupervisorDaemon({
     return decide('held', `早期警報からhold: ${warning.kind}/${warning.path}`, findingDigest);
   };
 
+  /**
+   * epoch駆動中に届いた、実在確認済みの警報。
+   *
+   * **駆動中はここへ積むだけにする。** epoch駆動はrun eventsをメモリに抱えたままawaitを
+   * またぎ、節目ごとに全体を置換する。その最中に横から追記すると、次の置換で消える——
+   * 静かに記録を失う方向に壊れる。捌くのは駆動側の安全点（disk とメモリが一致している点）
+   * であり、そこはworkerがまだ走っている最中なのでholdが成立する。
+   */
+  const pendingEscalations = [];
+  let epochDriveActive = false;
+
   /**
    * 警報1件の全行程（probe → 記録 → escalation）。
    *
@@ -1980,6 +2185,11 @@ export async function runManagedSupervisorDaemon({
   const handleIoWarning = async (warning, packets) => {
     const probed = await probeWarning(warning).catch(() => (
       { outcome: 'unprobed', writers: [], checkpoints: {} }));
+    if (probed.outcome === 'observed' && epochDriveActive) {
+      pendingEscalations.push({ warning, probed, packets });
+      await recordIoWarning(warning, 'observed');
+      return;
+    }
     const decided = probed.outcome === 'observed'
       ? await escalateIoWarning(warning, probed, packets).catch(() => null)
       : null;
@@ -1987,17 +2197,51 @@ export async function runManagedSupervisorDaemon({
       decided === null || decided.outcome === 'skipped' ? probed.outcome : 'escalated');
   };
 
+  /**
+   * epoch駆動の安全点でescalationを捌く（ADR 0143）。
+   *
+   * 呼ぶのは`replaceEventsAtomically`の直後だけとする。そこではdiskとメモリのeventsが
+   * 一致しているので、control operationがdiskを読み書きしても駆動側の像とずれない。
+   * 捌いた後はdiskを読み直して返す——`conflict`と`hold`はevents.jsonを書き換えるため。
+   *
+   * lifecycle lockは取らない。既に駆動側（activate）が握っている内側であり、ここで
+   * 取り直すと自分自身を待つ。同じ理由で`handler`ではなく`executeControl`を直接使う。
+   *
+   * @returns {Promise<Array|null>} 捌いた結果のevents。何も捌かなければnull。
+   */
+  const drainPendingEscalations = async (events) => {
+    if (pendingEscalations.length === 0) return null;
+    let current = events;
+    while (pendingEscalations.length > 0) {
+      const { warning, probed, packets } = pendingEscalations.shift();
+      const decided = await escalateIoWarning(warning, probed, packets, {
+        recordCheckpoints: recordProbeCheckpointsUnlocked,
+        dispatchControl: (controlRequest) => executeControl(controlRequest),
+      }).catch((error) => ({ outcome: 'rejected',
+        detail: String(error?.message ?? error), finding_digest: null }));
+      if (decided === null) continue;
+      current = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
+      // holdが掛かったら、残りの警報は同じfreezeの下にある。二重にholdを試みない。
+      if (projectRuntimeState({ events: current }).freeze !== null) break;
+    }
+    return current;
+  };
+
   /** 警報の処理を直列化する鎖。`onWarning`はここへ繋ぐだけにする。 */
   let escalationChain = Promise.resolve();
 
-  const resolveObservationBinding = async ({ binding }) => {
+  const resolveObservationBinding = async ({ binding, ack }) => {
+    // rebind経路はrunning bindingを持たず、ackだけで来る（`kind: 'rebind'`）。どちらから来ても
+    // 同じdispatch記録へ辿り着けなければ、繋ぎ直す相手を特定できない。
+    const todoId = binding?.todo_id ?? ack?.todo_id;
+    const executorHandle = binding?.executor_handle ?? ack?.executor_handle;
     const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
     const dispatch = events.findLast((event) => event.kind === 'executor_dispatched'
-      && event.subject?.kind === 'todo' && event.subject.ref === binding?.todo_id
-      && event.payload?.executor_handle === binding?.executor_handle);
+      && event.subject?.kind === 'todo' && event.subject.ref === todoId
+      && event.payload?.executor_handle === executorHandle);
     const observation = dispatch?.payload?.direct_os_observation_binding;
     if (observation === null || typeof observation !== 'object' || Array.isArray(observation)) {
-      throw new ManagedRuntimeError('HOLD_ACKS_INCOMPLETE', `durable Direct OS binding不足: ${binding?.todo_id ?? 'unknown'}`);
+      throw new ManagedRuntimeError('HOLD_ACKS_INCOMPLETE', `durable Direct OS binding不足: ${todoId ?? 'unknown'}`);
     }
     return structuredClone(observation);
   };
@@ -2115,18 +2359,24 @@ export async function runManagedSupervisorDaemon({
               return settled;
             },
           });
-          await driveInitialScriptedManagedEpoch({
-            runDir,
-            repoRoot,
-            request,
-            committed,
-            activation,
-            managedSupervisor,
-            sentinel,
-            initialEvents: events,
-            controlEvents: () => controlEvents,
-            preDispatchBindings,
-          });
+          epochDriveActive = true;
+          try {
+            await driveInitialScriptedManagedEpoch({
+              runDir,
+              repoRoot,
+              request,
+              committed,
+              activation,
+              managedSupervisor,
+              sentinel,
+              initialEvents: events,
+              controlEvents: () => controlEvents,
+              preDispatchBindings,
+              drainEscalations: drainPendingEscalations,
+            });
+          } finally {
+            epochDriveActive = false;
+          }
         }
         if (restarting) {
           await managedSupervisor.recoveryBarrier({ barrierId: `recovery-${randomUUID()}`,
@@ -2316,6 +2566,19 @@ export async function runManagedSupervisorDaemon({
         if (finding.plan_epoch !== active.pointer.plan_epoch) {
           throw new ManagedRuntimeError('STALE_FINDING', 'findingはactive epochに属さない');
         }
+        // 競合は2者以上いて初めて競合である。1者しか名指していない観測——誰の領分とも
+        // 重なっていない予測超過——でfreezeすると、抜け道が無い。処置は2つとも2者を要求する
+        // （直列化は`todo_ids.length >= 2`、seam変換は2つの面へ切る）ので、legalなrecompileが
+        // 作れないまま止まる。予測が狭かっただけなので、記録して次のcompileで宣言を実態へ
+        // 合わせるのが正しい応答である。
+        if ((finding.finding?.todo_ids ?? []).length < 2) {
+          throw new ManagedRuntimeError('FINDING_NOT_A_CONFLICT',
+            '1 TODOしか名指していない観測はfreezeへ運べない。'
+            + '予測超過は競合ではないので、記録のまま次のcompileで宣言を観測へ合わせる', {
+              finding_kind: finding.finding?.kind ?? null,
+              todo_ids: [...(finding.finding?.todo_ids ?? [])],
+            });
+        }
         let events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
         const todoId = finding.finding?.todo_ids?.[0] ?? active.bundle.plan.nodes[0].todo_id;
         events.push(buildNextRunEvent({ events, runId: request.request_id, kind: 'conflict_found', planEpoch: active.pointer.plan_epoch,
@@ -2534,20 +2797,40 @@ export async function runManagedSupervisorDaemon({
             !== canonicalizeArtifact(treatment.todo_ids ?? treatment.predecessor_task_ids)) {
           throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'treatmentがhold finding/todo集合と一致しない');
         }
-        if (recompileRequest.mode === 'intentional_serial'
-          && treatmentFinding.finding.resource_id !== treatment.resource_id) {
-          throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceがfinding resourceと一致しない');
-        }
-        if (recompileRequest.mode === 'intentional_serial'
-          && !treatment.todo_ids.every((todoId) => {
-            const manifest = active.bundle.manifests[todoId];
-            return manifest?.resources?.includes(treatment.resource_id)
-              || manifest?.state_effects?.some((effect) => effect.resource_id === treatment.resource_id);
-          })) {
-          throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceをfresh ownershipから再導出できない');
+        if (recompileRequest.mode === 'intentional_serial') {
+          // **path競合には資源idが無い。** finding契約はpath形の`resource_id`をnullと定めており、
+          // path由来の資源idはmanifestの`resources`にも載らない（載るのは宣言したbare資源だけ）。
+          // それでもrouteConflictTreatmentはpath競合を直列化レーンへ振る——請求項7の
+          // 「一方を停止し、他方を確定し、停止した方を再開する」がその経路だからである。
+          //
+          // よってpath findingの時は、係争pathからfront-endと同じ形で資源idを導出して照合する。
+          // 導出値との一致を要求するので、資源idを捏造できないという元の保証は保たれる
+          // ——照合先がfindingそのものへ固定されるため、manifest所属を見る必要が無い。
+          const expectedResource = treatmentFinding.finding.path === null
+            ? treatmentFinding.finding.resource_id
+            : ownedPathResourceId(treatmentFinding.finding.path);
+          if (expectedResource !== treatment.resource_id) {
+            throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceがfinding resourceと一致しない');
+          }
+          // 宣言済み資源の競合は、従来どおり実ownershipから再導出できることまで要求する。
+          if (treatmentFinding.finding.path === null
+            && !treatment.todo_ids.every((todoId) => {
+              const manifest = active.bundle.manifests[todoId];
+              return manifest?.resources?.includes(treatment.resource_id)
+                || manifest?.state_effects?.some((effect) => effect.resource_id === treatment.resource_id);
+            })) {
+            throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceをfresh ownershipから再導出できない');
+          }
         }
         if (recompileRequest.mode === 'seam_split') {
+          // **宣言された面の所有も数える。** `resources`／`state_effects`だけを見ていた間、
+          // path所有はbefore/afterのどちらにも現れず、seam splitが述べる`added`は常に空の
+          // 導出値と突き合わされていた——path競合を切るsplitは原理的に一致しなかった。
+          // 資源idの合成形は`verifySeamSplitSuccessor`と同じ`own-<kind>-<sha16>`にする。
           const ownership = (manifests) => Object.entries(manifests).flatMap(([todoId, manifest]) => [
+            ...(manifest.owns ?? []).map((own) => ({
+              resource_id: ownedResourceId(own.kind, own.target),
+              owner_todo_id: todoId, access_kind: 'own' })),
             ...manifest.resources.map((resourceId) => ({ resource_id: resourceId,
               owner_todo_id: todoId, access_kind: 'own' })),
             ...manifest.state_effects.map((effect) => ({ resource_id: effect.resource_id,
@@ -2561,9 +2844,41 @@ export async function runManagedSupervisorDaemon({
           ].sort((left, right) => canonicalizeArtifact(left).localeCompare(canonicalizeArtifact(right)));
           const difference = (left, right) => left.filter((entry) => !right.some((other) =>
             canonicalizeArtifact(entry) === canonicalizeArtifact(other)));
-          const beforeOwnership = ownership(active.bundle.manifests);
+          // **比較の起点は、観測へ合わせた後の宣言である。**
+          //
+          // 実行時に見つかった競合は、片方がその資源を所有していないから起きる。変換はその
+          // 宣言を観測へ合わせてから導出されるので（翻訳段）、splitが述べる遷移も合わせた後の
+          // 状態からのものになる。ここで記録のままのpredecessorと比べると、実行時に見つかった
+          // 競合から作ったsplitは永久に一致しない——請求項8が実行時に届かなくなる。
+          //
+          // 合わせる材料はfindingそのものであり、宣言でも入力でもない。再導出なので、
+          // 呼び出し側が何を主張しても結果は変わらない。
+          const contestedResource = treatmentFinding.finding.path === null
+            ? treatmentFinding.finding.resource_id
+            : ownedPathResourceId(treatmentFinding.finding.path);
+          const observedTodoIds = [...treatmentFinding.finding.todo_ids].sort();
+          const reconciledOwnership = [...ownership(active.bundle.manifests)];
+          for (const todoId of observedTodoIds) {
+            const entry = { resource_id: contestedResource, owner_todo_id: todoId, access_kind: 'own' };
+            if (!reconciledOwnership.some((other) => canonicalizeArtifact(other) === canonicalizeArtifact(entry))) {
+              reconciledOwnership.push(entry);
+            }
+          }
+          const reconciledEdges = [...edges(active.bundle.plan)];
+          for (let left = 0; left < observedTodoIds.length; left += 1) {
+            for (let right = left + 1; right < observedTodoIds.length; right += 1) {
+              const edge = { from_todo_id: observedTodoIds[left], to_todo_id: observedTodoIds[right],
+                kind: 'conflict' };
+              if (!reconciledEdges.some((other) => canonicalizeArtifact(other) === canonicalizeArtifact(edge))) {
+                reconciledEdges.push(edge);
+              }
+            }
+          }
+          const sortEntries = (entries) => [...entries]
+            .sort((left, right) => canonicalizeArtifact(left).localeCompare(canonicalizeArtifact(right)));
+          const beforeOwnership = sortEntries(reconciledOwnership);
           const afterOwnership = ownership(compiled.manifests);
-          const beforeEdges = edges(active.bundle.plan);
+          const beforeEdges = sortEntries(reconciledEdges);
           const afterEdges = edges(newPlan);
           const derivedOwnership = { added: difference(afterOwnership, beforeOwnership),
             removed: difference(beforeOwnership, afterOwnership) };
@@ -2712,6 +3027,20 @@ export async function runManagedSupervisorDaemon({
           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 ?? [];
@@ -2889,9 +3218,22 @@ export async function runManagedSupervisorDaemon({
             recordedAt: canonicalNow() })];
         }
         await replaceEventsAtomically(runDir, events);
-        // abandonは成果を捨てる決定なので、workerの木も畳む。closeでは畳まない——
-        // 木そのものがrunの成果であり、着地させる前に消したら受理した内容が残らない。
+        // **abandonは成果を捨てる決定である。** worker processの終了はcleanupではなく
+        // その決定の一部なので、誰を止めたかを記録へ残す。closeでは何もしない——
+        // 完走したrunのworkerは既にterminalであり、生きていればそれは欠陥である
+        // （`closeRunIfComplete`が全TODO accepted を要求するので、そもそもcloseへ来ない）。
         if (controlRequest.operation === 'abandon') {
+          const reaped = await reapRunWorkerProcesses({ events }).catch(() => null);
+          if (reaped !== null && (reaped.reaped.length > 0 || reaped.skipped.length > 0)) {
+            await appendControl({ run_id: request.request_id, kind: 'worker_processes_terminated',
+              session_nonce_digest: digestArtifact(sessionNonce), payload: {
+                reason: shutdownReason,
+                terminated_pids: [...reaped.reaped].sort((left, right) => left - right),
+                skipped_count: reaped.skipped.length,
+              } });
+          }
+          // 木も畳む。closeでは畳まない——木そのものがrunの成果であり、着地させる前に
+          // 消したら受理した内容が残らない。
           await removeScriptedWorktrees({ repoRoot, runDir }).catch(() => null);
         }
         await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
@@ -3415,6 +3757,11 @@ export async function runManagedSupervisorDaemon({
     // 監視fdを残さない。取り残すとtest fixtureの後片付けが重くなる。
     sentinel?.close();
     sentinel = null;
+    // **これは事故処理であって、正しい閉じ方ではない。** 正規の終了はabandon（破棄の決定）か
+    // hold後の再開であり、そのどちらも通らずdaemonが落ちる時だけここへ来る。停止した
+    // workerは自分では終われないので、記録から辿って道連れにする。
+    await readBoundedJson(path.join(runDir, 'events.json'), 'run events')
+      .then((events) => reapRunWorkerProcesses({ events })).catch(() => null);
     if (activationCommitted && activation !== null) {
       await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
         session_nonce_digest: digestArtifact(sessionNonce), payload: { signal } });
@@ -3580,6 +3927,16 @@ export async function runRuntimeCli({ argv, cwd, stdout, stderr }) {
         requestId: requestIdOverride,
       });
     };
+  } else if (argv.length === 9
+    && argv[0] === 'run' && argv[1] === 'seam' && argv[2] === 'profile'
+    && argv[3] === '--run' && typeof argv[4] === 'string' && argv[4].length > 0
+    && argv[5] === '--finding' && /^[0-9a-f]{64}$/u.test(argv[6])
+    && argv[7] === '--input' && typeof argv[8] === 'string' && argv[8].length > 0) {
+    action = async () => {
+      const { repoRoot, runDir } = await resolveRunStore(cwd, argv[4]);
+      return runSeamProfile({ runDir, repoRoot, findingDigest: argv[6],
+        inputPath: path.resolve(cwd, argv[8]), stdout });
+    };
   } else if (argv.length === 9
     && argv[0] === 'run' && argv[1] === 'seam' && argv[2] === 'resolve'
     && argv[3] === '--run' && typeof argv[4] === 'string' && argv[4].length > 0