@quolu/lattice 0.30.1 → 0.32.0

package/bin/lattice-scripted-worker.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * scripted executorのworker process（ADR 0143 Decision 9）。
+ *
+ * **別processであること自体が要件である。** holdは静止の証明を要求し、直接OS観測は
+ * executorのprocessが実際に停止していることまで確かめる。controller自身のprocessで
+ * 作業していると、止めれば応答できず、止めなければ証明できない。
+ *
+ * 書いたあとも生きたまま待つ。作業を終えて消えてしまうと、barrierが掛かった時に
+ * 止めるべきprocessが存在せず、静止を証明する相手が居なくなる。
+ */
+
+import { readFile } from 'node:fs/promises';
+
+import { executePacket } from '../src/runtime-scripted-adapter-controller.mjs';
+
+const MAX_JOB_BYTES = 8_388_608;
+
+function fail(reason) {
+  process.stderr.write(`${JSON.stringify({
+    schema: 'lattice.scripted_worker_error.v1', reason,
+  })}\n`);
+  process.exit(1);
+}
+
+const jobPath = process.argv[2];
+if (typeof jobPath !== 'string' || jobPath.length === 0) fail('job pathが渡されていない');
+
+let job;
+try {
+  const bytes = await readFile(jobPath);
+  if (bytes.length > MAX_JOB_BYTES) fail('jobが上限byteを超える');
+  job = JSON.parse(bytes.toString('utf8'));
+} catch (error) {
+  fail(`jobを読めない: ${String(error?.message ?? error)}`);
+}
+if (job?.schema !== 'lattice.scripted_worker_job.v1') fail('job schemaが不正');
+
+let result;
+try {
+  result = await executePacket({
+    packet: job.packet,
+    repoRoot: job.worktree_path,
+    extraWrites: job.extra_writes ?? [],
+  });
+} catch (error) {
+  fail(`実行に失敗した: ${String(error?.detail?.reason ?? error?.message ?? error)}`);
+}
+
+// 完了はstdoutの1行で報せる。controllerはこれを受けてreceiptを組む。
+process.stdout.write(`${JSON.stringify({
+  schema: 'lattice.scripted_worker_result.v1',
+  observed_diff: result.observedDiff,
+  checkpoint_digest: result.checkpointDigest,
+})}\n`);
+
+// 生きたまま待つ。ここがrunの「作業中」であり、barrierはこのprocessを止めて静止を証明する。
+const holdMs = Number.isSafeInteger(job.hold_ms) && job.hold_ms > 0 ? job.hold_ms : 0;
+if (holdMs > 0) await new Promise((resolve) => { setTimeout(resolve, holdMs); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.30.1",
+  "version": "0.32.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/runtime-cli.mjs

@@ -19,7 +19,7 @@ import { fileURLToPath } from 'node:url';
 
 import { canonicalizeArtifact, digestArtifact } from './artifact-contracts.mjs';
 import { collectSensorEvidence } from './sensor-adapter.mjs';
-import { detectCheckpointFindings } from './runtime-diff-observer.mjs';
+import { captureWorktreeDiff, detectCheckpointFindings } from './runtime-diff-observer.mjs';
 import {
   buildIoEscalation, createRunSentinel, probeIoWarning, syncSentinelWatches,
 } from './runtime-io-sentinel.mjs';
@@ -139,6 +139,9 @@ const KNOWN_ADAPTERS = Object.freeze(['scripted', 'isolated-worktree', 'actual-a
  * 超えたら`rejected`として理由ごとjournalへ残す（黙って見送らない）。
  */
 const IO_ESCALATION_LOCK_TIMEOUT_MS = 15_000;
+/** 走行中workerの完了を待つ上限と間隔。待てないと走行中の観測が成立しない。 */
+const SCRIPTED_OBSERVE_TIMEOUT_MS = 120_000;
+const SCRIPTED_OBSERVE_POLL_MS = 20;
 
 class CliContractError extends Error {
   constructor(code, message, detail) {
@@ -750,13 +753,14 @@ async function driveInitialScriptedManagedEpoch({
   initialEvents,
   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;
@@ -777,9 +781,13 @@ async function driveInitialScriptedManagedEpoch({
     // 木がTODOごとに分かれて初めて、書き込みの帰属をrootから決められる。
     const worktreeByTodo = new Map();
     for (const todoId of frontier) {
-      worktreeByTodo.set(todoId, await ensureScriptedWorktree({
+      const worktreePath = await ensureScriptedWorktree({
         repoRoot, runDir, packet: packets[todoId],
-      }));
+      });
+      worktreeByTodo.set(todoId, worktreePath);
+      preDispatchBindings?.set(todoId, {
+        worktree_path: worktreePath, base_sha: packets[todoId].base_sha,
+      });
     }
     syncSentinelWatches({ sentinel, runningTodoIds: [...frontier],
       rootOf: (todoId) => worktreeByTodo.get(todoId) });
@@ -854,12 +862,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,
           },
         };
@@ -869,15 +884,19 @@ async function driveInitialScriptedManagedEpoch({
           event.kind === 'executor_dispatched'
           && event.payload?.executor_handle === executorHandle
         ));
+        // **ここで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がterminal以外を返した: ${response.observation.state}`,
+            `scripted controllerが未知のstateを返した: ${response.observation.state}`,
           );
         }
         const receipt = await readScriptedControllerReceipt({
@@ -911,22 +930,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,
@@ -1738,6 +1787,14 @@ export async function runManagedSupervisorDaemon({
    * probeが撮るのはgitから読んだ本物のdiffなので、そのままfindingの証拠になる。
    * fs eventをfindingへ昇格させる必要が無く、契約を1つも緩めずに済む。
    */
+  /**
+   * dispatch event耐久化より前のobservation binding。
+   *
+   * frontierのworktreeを用意した時点でsupervisorが知っている値を置く。警報はdispatchの
+   * 最中に飛ぶので、eventの耐久化を待つと最も早い観測を取り逃す。
+   */
+  const preDispatchBindings = new Map();
+
   const probeWarning = async (warning) => {
     const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events')
       .catch(() => null);
@@ -1749,7 +1806,12 @@ export async function runManagedSupervisorDaemon({
     for (const todoId of warning.todo_ids) {
       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;
+      // dispatch eventは、frontier全体のdispatchが終わってから一括で耐久化される。
+      // 警報はその最中に飛ぶので、eventだけを頼りにすると**いちばん早い観測を必ず取り逃す**。
+      // supervisorはdispatchの前にworktreeを用意した時点で同じbindingを知っているので、
+      // そちらを先に見る。値はどちらも同一で、早いか遅いかの違いしかない。
+      const binding = dispatch?.payload?.direct_os_observation_binding
+        ?? preDispatchBindings.get(todoId);
       if (typeof binding?.worktree_path !== 'string' || typeof binding?.base_sha !== 'string') continue;
       roots[todoId] = binding.worktree_path;
       // 観測できないTODOは「書いていない」へ丸めない。probeIoWarningが未観測として扱う。
@@ -1775,6 +1837,15 @@ export async function runManagedSupervisorDaemon({
    * 「両方が書いた」と読めてしまう。これをholdへ繋ぐと、無実のTODOを止める。
    * 帰属が立たないならescalationへ進めない。警報と実在の記録はそのまま残す。
    */
+  /**
+   * holdが要求する静止を、この構成で証明できるか。
+   *
+   * 直接OS観測はexecutorのprocessが停止していることを実測する。scripted controllerは
+   * 自分のprocessで作業するので、そのprocessを止めると制御そのものが止まる——止めない限り
+   * 証明できず、止めれば応答できない。**別processのexecutorを持つまでこの穴は埋まらない。**
+   */
+  const canProveQuiescence = () => true;
+
   const attributionIsDistinct = (warning, roots) => {
     const paths = warning.todo_ids.map((todoId) => roots[todoId]);
     if (paths.some((value) => typeof value !== 'string')) return false;
@@ -1788,7 +1859,7 @@ export async function runManagedSupervisorDaemon({
    * 事後に再読して再導出できる主張であることの担保である。fs eventは取りこぼすし再読もできない。
    * ここで残すのは「機械が気づいた」という事実だけで、判定の正本はcheckpointのままである。
    *
-   * 記録しない選択肢は無い。気づいたのに黙っている状態を残さない（ADR 0130）。
+   * 記録しない選択肢は無い。気づいたのに黙っている状態を残さない。
    */
   const warningDigestOf = (warning) => digestArtifact({
     warning_kind: warning.kind, todo_ids: [...warning.todo_ids].sort(), path: warning.path,
@@ -1818,17 +1889,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' };
@@ -1859,6 +1920,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();
     }
@@ -1874,7 +1952,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;
@@ -1893,7 +1974,20 @@ export async function runManagedSupervisorDaemon({
       return decide('skipped',
         'worktree rootを共有する構成では書き手を特定できない（帰属はrootだけで決まる）');
     }
-    const recorded = await durablyRecordProbeCheckpoints(escalation, probed.checkpoints);
+    // **holdは静止の証明を要求する。** 直接OS観測はexecutorのprocessが実際に停止している
+    // ことまで確かめるが、executorがcontroller自身のprocessである構成では、止めると
+    // 制御そのものが止まるので証明できない。
+    //
+    // ここで止めるのは、conflictがintakeをfreezeするからである。freezeしてholdが通らない
+    // 状態を作ると、runは進むことも畳むこともできなくなる（abandonも静止を要求する）。
+    // 止められないと分かっているなら、freezeさせない方が安全側である。判定はcheckpointが
+    // 従来どおり担う——早期警報は早めるためだけに在るという原則どおり。
+    if (!canProveQuiescence()) {
+      return decide('rejected',
+        'executorがcontroller自身のprocessで走っており、静止を証明できない'
+        + '（停止すると制御も止まる）。freezeさせるとrunを畳めなくなるので進めない');
+    }
+    const recorded = await recordCheckpoints(escalation, probed.checkpoints);
     if (!recorded.ok) return decide(recorded.outcome, recorded.detail);
 
     const submit = async (operation, { artifact = null, artifactDigest = null,
@@ -1905,13 +1999,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)] } }));
@@ -1935,6 +2031,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）。
    *
@@ -1945,6 +2052,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;
@@ -1952,6 +2064,36 @@ 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();
 
@@ -2080,17 +2222,24 @@ export async function runManagedSupervisorDaemon({
               return settled;
             },
           });
-          await driveInitialScriptedManagedEpoch({
-            runDir,
-            repoRoot,
-            request,
-            committed,
-            activation,
-            managedSupervisor,
-            sentinel,
-            initialEvents: events,
-            controlEvents: () => controlEvents,
-          });
+          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()}`,

package/src/runtime-control-store.mjs

@@ -158,7 +158,7 @@ export function validateRuntimeControlEventPayload(kind, value) {
   }
   // I/O sentinelの早期警報（ADR 0143）。**findingではない**——検知の正本はcheckpointのままで、
   // これは「早くcheckpointを撮って確かめろ」という引き金の記録である。記録しない選択肢は無い:
-  // 機械が何かに気づいたのに黙っている状態を残さない（ADR 0130）。
+  // 機械が何かに気づいたのに黙っている状態を残さない。
   if (kind === 'io_warning_observed') {
     return exact(value, ['warning_kind', 'todo_ids', 'path', 'probe_outcome', 'warning_digest'])
       && ['io_overlap_warning', 'io_scope_warning'].includes(value.warning_kind)

package/src/runtime-controller-protocol.mjs

@@ -31,8 +31,8 @@ const WIRES = Object.freeze({
   dispatch: {
     request: ['schema', 'request_id', 'registration_digest', 'packet', 'write_lease', 'request_digest'],
     requestSchema: 'lattice.adapter_dispatch_request.v1',
-    response: ['schema', 'request_id', 'executor_handle', 'worktree_id', 'packet_digest', 'lease_digest', 'response_digest'],
-    responseSchema: 'lattice.adapter_dispatch_response.v1',
+    response: ['schema', 'request_id', 'executor_handle', 'worktree_id', 'packet_digest', 'lease_digest', 'worker_process', 'response_digest'],
+    responseSchema: 'lattice.adapter_dispatch_response.v2',
   },
   observe: {
     request: ['schema', 'request_id', 'registration_digest', 'executor_handle', 'expected_epoch', 'expected_lease_digest', 'request_digest'],
@@ -338,8 +338,12 @@ export function validateControllerResponse(operation, value, expectedRequestId =
   if (!(Boolean(wire) && exact(value, wire.response) && value.schema === wire.responseSchema
     && identifier(value.request_id) && (expectedRequestId === null || value.request_id === expectedRequestId)
     && selfValid(value, 'response_digest'))) return false;
+  // v2で`worker_process`を必須にした。executorがcontroller自身のprocessだと、holdが
+  // 要求する静止を証明できない（止めれば応答できず、止めなければ証明できない）。
+  // 誰を止めればよいかをdispatchの時点で名指しさせる。
   if (operation === 'dispatch') return identifier(value.executor_handle) && identifier(value.worktree_id)
-    && digest(value.packet_digest) && digest(value.lease_digest);
+    && digest(value.packet_digest) && digest(value.lease_digest)
+    && validateExpectedWorkerProcess(value.worker_process);
   if (operation === 'observe') return exact(value.observation, ['schema', 'state', 'executor_handle', 'plan_epoch', 'lease_digest', 'payload_digest', 'observation_digest'])
     && value.observation.schema === 'lattice.adapter_observation.v1'
     && ['running', 'checkpoint_ready', 'terminal', 'held'].includes(value.observation.state)
@@ -397,6 +401,20 @@ function validateProtocolRunningBinding(value) {
     && identifier(value.write_lease_id) && digest(value.controller_registration_digest);
 }
 
+/**
+ * dispatchが名指しするworker process。直接OS観測が期待するchild processと同じ形にする
+ * ——照合先の形が分かれると、supervisorとcontrollerが別のものを見ていても気づけない。
+ */
+export function validateExpectedWorkerProcess(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).sort().join('\0')
+      === ['pid', 'process_group_id', 'process_start_identity'].sort().join('\0')
+    && Number.isSafeInteger(value.pid) && value.pid > 0
+    && Number.isSafeInteger(value.process_group_id) && value.process_group_id > 0
+    && validateProcessStartIdentity(value.process_start_identity)
+    && value.process_start_identity.pid === value.pid;
+}
+
 export function validateQuiescenceAck(value) {
   return exact(value, ['schema', 'ack_id', 'run_id', 'todo_id', 'executor_handle', 'worktree_id', 'plan_epoch', 'packet_digest', 'write_lease_id', 'barrier_control_digest', 'final_checkpoint_digest', 'process_observation_digest', 'worktree_fingerprint_digest', 'supervisor_session_nonce_digest', 'ack_digest'])
     && value.schema === 'lattice.executor_quiescence_ack.v1'

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

@@ -1,6 +1,6 @@
 import net from 'node:net';
 import { createHash, randomBytes } from 'node:crypto';
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { constants as fsConstants, readFileSync } from 'node:fs';
 import {
   chmod,
@@ -13,6 +13,7 @@ import {
   rm,
 } from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 
 import { canonicalizeArtifact, digestArtifact } from './artifact-contracts.mjs';
@@ -29,6 +30,7 @@ import {
   validateExecutorPacket,
   validateExecutorReceipt,
 } from './runtime-contracts.mjs';
+import { captureWorktreeDiff } from './runtime-diff-observer.mjs';
 import { validateSupervisorWriteGate } from './runtime-gate-store.mjs';
 import { observeManagedProcessStartIdentity } from './runtime-managed-supervisor.mjs';
 import { scriptedWorktreeId, scriptedWorktreePath } from './runtime-scripted-worktree.mjs';
@@ -251,15 +253,25 @@ function deterministicWriteBytes(packet, relativePath) {
   })}\n`);
 }
 
-async function executePacket({ packet, repoRoot }) {
+/**
+ * packetの宣言writeを実行する。**worker processから呼ばれる。**
+ *
+ * controllerと同じprocessで走らせていた頃、このrunには走行中のTODOが存在せず、
+ * 実行時の観測も静止の証明も原理的に成立しなかった（ADR 0143 Decision 7・9）。
+ */
+export async function executePacket({ packet, repoRoot, extraWrites = [] }) {
   const writes = packet.scope?.writes;
   if (!Array.isArray(writes) || writes.length === 0
     || writes.some((entry, index) => !safeWritePath(entry)
       || (index > 0 && writes[index - 1] >= entry))) {
     fail('SCRIPTED_PACKET_REJECTED', 'scope.writesは非空の昇順一意pathでなければならない');
   }
+  // 宣言scope外への書き込みは、検知そのものを検証するために要る。writeがすべて宣言内に
+  // 収まる限り、実行時competitionは原理的に一度も起きないので、検知経路を実runで通せない。
+  // 宣言と実writeが食い違う状態を意図して作れることが、この面の受入条件である。
+  const allWrites = [...new Set([...writes, ...extraWrites])].sort();
   const prepared = [];
-  for (const relativePath of writes) {
+  for (const relativePath of allWrites) {
     const target = await requireSafeTarget(repoRoot, relativePath);
     const existedAtBase = await basePathExists(repoRoot, packet.base_sha, relativePath);
     prepared.push({
@@ -318,6 +330,122 @@ async function readAndValidateGate(runDir, writeLease) {
  * supervisor controller protocolを実装する決定論的scripted adapter。
  * 時刻はheartbeat schedulingだけに使い、write bytes／handle／receiptへ混入させない。
  */
+/**
+ * 登録済みadapter configから、このcontrollerの振る舞いを読む。
+ *
+ * **configはregistrationのdigestへ束縛されている。** repo内の任意のfileを信用するのではなく、
+ * `run adapter register`が記録した`config_digest`と一致するbytesだけを受ける。一致しなければ
+ * 既定の振る舞いへ落とすのではなく止める——registrationと実configがずれた状態で走ると、
+ * 記録されたrunの再現性が壊れる。
+ *
+ * 読むのは3つだけ:
+ * - `hold_ms`: 書き込み後にworkerが走り続ける時間。実行時観測が成立する窓を作る。
+ * - `extra_writes`: 宣言scope外へのwrite。競合検知そのものを検証するために要る。
+ * - `mode`: 既存の`deterministic`のみ。未知の値は黙って無視せず止める。
+ */
+async function readScriptedBehavior(repoRoot) {
+  const descriptorPath = path.join(repoRoot, '.lattice', 'runtime', 'adapter-registry',
+    'descriptors', 'scripted.json');
+  let descriptor;
+  try {
+    descriptor = JSON.parse(await readFile(descriptorPath, 'utf8'));
+  } catch {
+    // 未登録のまま走らせる経路（unit test等）は既定の振る舞いで動かす。
+    return { hold_ms: 0, extra_writes: [] };
+  }
+  if (typeof descriptor?.config_ref !== 'string' || typeof descriptor.config_digest !== 'string') {
+    return { hold_ms: 0, extra_writes: [] };
+  }
+  const configPath = path.join(repoRoot, ...descriptor.config_ref.split('/'));
+  let bytes;
+  try {
+    bytes = await readFile(configPath);
+  } catch {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', '登録済みadapter configを読めない', {
+      config_ref: descriptor.config_ref,
+    });
+  }
+  if (sha256Bytes(bytes) !== descriptor.config_digest) {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', 'adapter configが登録時のdigestと一致しない', {
+      config_ref: descriptor.config_ref,
+    });
+  }
+  let config;
+  try {
+    config = JSON.parse(bytes.toString('utf8'));
+  } catch {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', 'adapter configのJSONが不正');
+  }
+  if (config?.mode !== undefined && config.mode !== 'deterministic') {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', `未知のscripted mode: ${String(config.mode)}`);
+  }
+  const holdMs = config?.hold_ms ?? 0;
+  if (!Number.isSafeInteger(holdMs) || holdMs < 0 || holdMs > 600_000) {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', 'hold_msが不正');
+  }
+  const extraWrites = config?.extra_writes ?? [];
+  if (!Array.isArray(extraWrites) || extraWrites.some((entry) => !safeWritePath(entry))) {
+    fail('SCRIPTED_BOOTSTRAP_INVALID', 'extra_writesが不正');
+  }
+  return { hold_ms: holdMs, extra_writes: [...extraWrites] };
+}
+
+const WORKER_ENTRYPOINT = fileURLToPath(new URL('../bin/lattice-scripted-worker.mjs', import.meta.url));
+
+/**
+ * worker processを起こす（ADR 0143 Decision 9）。
+ *
+ * `detached`で独立process groupへ置く。controllerと同じgroupに居ると、直接OS観測が
+ * 「未記録process group memberを検出」として落とす——正しく落ちるので、ここを外さない。
+ *
+ * 起動直後にprocess start identityを観測して束ねる。pidは再利用されうるので、
+ * pidだけでは「同じprocessか」を後から言えない。
+ */
+async function spawnScriptedWorker({ packet, worktreePath, extraWrites, holdMs,
+  controllerId, runDir }) {
+  const job = {
+    schema: 'lattice.scripted_worker_job.v1',
+    packet: structuredClone(packet),
+    worktree_path: worktreePath,
+    extra_writes: [...extraWrites],
+    hold_ms: holdMs,
+  };
+  const jobPath = path.join(runDir, 'controllers', controllerId, 'jobs',
+    `${packet.packet_digest}.json`);
+  await durableReplaceBytes(jobPath, Buffer.from(`${canonicalizeArtifact(job)}\n`));
+  const child = spawn(process.execPath, [WORKER_ENTRYPOINT, jobPath], {
+    detached: true, stdio: ['ignore', 'pipe', 'pipe'], cwd: worktreePath,
+  });
+  if (!Number.isSafeInteger(child.pid)) {
+    fail('SCRIPTED_EXECUTION_FAILED', 'worker processを起こせない');
+  }
+  const identity = await observeManagedProcessStartIdentity(child.pid);
+  let stdout = '';
+  let stderr = '';
+  child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+  child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+  const completed = new Promise((resolve, reject) => {
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      const line = stdout.split('\n').find((entry) => entry.includes('scripted_worker_result'));
+      let parsed = null;
+      try { parsed = line === undefined ? null : JSON.parse(line); } catch { parsed = null; }
+      if (parsed?.schema !== 'lattice.scripted_worker_result.v1') {
+        reject(new TypeError(`worker結果を読めない (${signal ?? code}): ${stderr.trim() || '(出力なし)'}`));
+        return;
+      }
+      resolve({ observedDiff: parsed.observed_diff, checkpointDigest: parsed.checkpoint_digest });
+    });
+  });
+  return {
+    pid: child.pid,
+    process_group_id: child.pid,
+    process_start_identity: identity,
+    child,
+    completed,
+  };
+}
+
 export async function createScriptedAdapterController({
   bootstrap,
   runDir,
@@ -373,6 +501,7 @@ export async function createScriptedAdapterController({
     descriptor_digest: '',
   }, 'descriptor_digest');
   const sessionNonceDigest = digestArtifact(bootstrap.supervisor_session_nonce);
+  const behavior = await readScriptedBehavior(canonicalRepoRoot);
   const stagedLeases = new Map();
   const armedLeases = new Map();
   const preparedPackets = new Map();
@@ -381,6 +510,13 @@ export async function createScriptedAdapterController({
   let currentEpoch = 1;
   let registrationDigest = null;
 
+  /** dispatch応答が運ぶworker process。誰を止めればよいかをsupervisorへ名指しする。 */
+  const workerProcessOf = (task) => ({
+    pid: task.worker.pid,
+    process_group_id: task.worker.process_group_id,
+    process_start_identity: structuredClone(task.worker.process_start_identity),
+  });
+
   const persistReceipt = async (receipt) => {
     const payloadDigest = digestArtifact(receipt);
     const receiptPath = path.join(
@@ -529,12 +665,13 @@ export async function createScriptedAdapterController({
           fail('SCRIPTED_DUPLICATE_DISPATCH', '同じTODOへ異なるpacketをdispatchできない');
         }
         return sign({
-          schema: 'lattice.adapter_dispatch_response.v1',
+          schema: 'lattice.adapter_dispatch_response.v2',
           request_id: request.request_id,
           executor_handle: prior.executorHandle,
           worktree_id: prior.worktreeId,
           packet_digest: packet.packet_digest,
           lease_digest: writeLease.lease_digest,
+          worker_process: workerProcessOf(prior),
           response_digest: '',
         }, 'response_digest');
       }
@@ -551,47 +688,78 @@ export async function createScriptedAdapterController({
           worktree_path: worktreePath,
         });
       }
-      const { observedDiff, checkpointDigest } = await executePacket({
-        packet,
-        repoRoot: await realpath(worktreePath),
-      });
       const executorHandle = `scripted-${packet.packet_digest.slice(0, 24)}`;
       const worktreeId = scriptedWorktreeId(packet);
-      const receipt = sign({
-        schema: 'lattice.executor_receipt.v1',
-        receipt_id: `receipt-${packet.packet_digest.slice(0, 24)}`,
+      // **dispatchで作業を終わらせない。** 終わらせると、走行中のTODOが1つも存在しない
+      // runになり、実行時の観測——書き込みを見て、他のworkerとの重なりを掴む——が
+      // 原理的に成立しない。dispatchは作業を起こして返り、完了はobserveが拾う。
+      const progress = {
+        schema: 'lattice.scripted_adapter_progress.v1',
+        run_id: bootstrap.run_id,
+        todo_id: packet.todo_id,
         executor_handle: executorHandle,
         worktree_id: worktreeId,
-        base_sha: packet.base_sha,
-        plan_epoch: packet.plan_epoch,
-        packet_digest: packet.packet_digest,
-        todo_id: packet.todo_id,
-        checkpoint_digest: checkpointDigest,
-        observed_diff: observedDiff,
-        receipt_digest: '',
-      }, 'receipt_digest');
-      if (!validateExecutorReceipt(receipt)) {
-        fail('SCRIPTED_EXECUTION_FAILED', '生成receiptがexecutor contractを満たさない');
-      }
-      const payloadDigest = await persistReceipt(receipt);
+        state: 'running',
+      };
+      const worktreeReal = await realpath(worktreePath);
+      // **workerは別processで起こす。** controller自身のprocessで作業すると、holdが
+      // 要求する静止を証明できない——止めれば応答できず、止めなければ証明できない。
+      // `detached`で独立process groupへ置く。同じgroupにcontrollerが居ると、直接OS観測が
+      // 「未記録process group memberを検出」として正しく落とす。
+      const spawned = await spawnScriptedWorker({
+        packet, worktreePath: worktreeReal, extraWrites: behavior.extra_writes,
+        holdMs: behavior.hold_ms, controllerId, runDir: canonicalRunDir,
+      });
       const task = {
         packet: structuredClone(packet),
         lease: structuredClone(writeLease),
         executorHandle,
         worktreeId,
-        receipt,
-        payloadDigest,
-        state: 'terminal',
+        worktreePath: worktreeReal,
+        receipt: null,
+        payloadDigest: digestArtifact(progress),
+        state: 'running',
+        failure: null,
+        settled: null,
+        worker: spawned,
       };
       tasks.set(executorHandle, task);
       todoToHandle.set(packet.todo_id, executorHandle);
+      task.settled = (async () => {
+        try {
+          const { observedDiff, checkpointDigest } = await spawned.completed;
+          const receipt = sign({
+            schema: 'lattice.executor_receipt.v1',
+            receipt_id: `receipt-${packet.packet_digest.slice(0, 24)}`,
+            executor_handle: executorHandle,
+            worktree_id: worktreeId,
+            base_sha: packet.base_sha,
+            plan_epoch: packet.plan_epoch,
+            packet_digest: packet.packet_digest,
+            todo_id: packet.todo_id,
+            checkpoint_digest: checkpointDigest,
+            observed_diff: observedDiff,
+            receipt_digest: '',
+          }, 'receipt_digest');
+          if (!validateExecutorReceipt(receipt)) {
+            throw new TypeError('生成receiptがexecutor contractを満たさない');
+          }
+          task.payloadDigest = await persistReceipt(receipt);
+          task.receipt = receipt;
+          task.state = 'terminal';
+        } catch (error) {
+          // 失敗を走行中のまま放置しない。observeがtypedに落ちる形へ残す。
+          task.failure = String(error?.detail?.reason ?? error?.message ?? error);
+        }
+      })();
       return sign({
-        schema: 'lattice.adapter_dispatch_response.v1',
+        schema: 'lattice.adapter_dispatch_response.v2',
         request_id: request.request_id,
         executor_handle: executorHandle,
         worktree_id: worktreeId,
         packet_digest: packet.packet_digest,
         lease_digest: writeLease.lease_digest,
+        worker_process: workerProcessOf(task),
         response_digest: '',
       }, 'response_digest');
     }
@@ -602,6 +770,10 @@ export async function createScriptedAdapterController({
         || task.lease.lease_digest !== request.expected_lease_digest) {
         fail('SCRIPTED_OBSERVATION_REJECTED', 'observe bindingがdispatch記録と一致しない');
       }
+      // 走行中に落ちた作業を「まだ走っている」と言い続けない。
+      if (task.failure !== null) {
+        fail('SCRIPTED_EXECUTION_FAILED', 'worker実行が失敗した', { reason: task.failure });
+      }
       const observation = sign({
         schema: 'lattice.adapter_observation.v1',
         state: task.state,
@@ -641,23 +813,48 @@ export async function createScriptedAdapterController({
       }, 'response_digest');
     }
     if (operation === 'barrier') {
-      const acks = request.running_bindings.map((binding) => {
+      const acks = [];
+      for (const binding of request.running_bindings) {
         const task = tasks.get(binding.executor_handle);
         if (task === undefined || task.packet.todo_id !== binding.todo_id) {
           fail('SCRIPTED_BARRIER_REJECTED', 'barrierが未知のrunning bindingを含む');
         }
+        // **barrierは静止の宣言である。** worker processを実際に止め、止まった木を読む。
+        // 走行中の作業を残したままackを返すと、「止まった」と言いながらworktreeが動き続ける。
+        try {
+          process.kill(task.worker.pid, 'SIGSTOP');
+        } catch (error) {
+          fail('SCRIPTED_BARRIER_REJECTED', 'worker processを止められない', {
+            pid: task.worker.pid, reason: String(error?.code ?? error?.message ?? error),
+          });
+        }
         task.state = 'held';
+        // supervisorも同じ観測を独立に行い、3つのdigestの一致を要求する。**こちらが別の形で
+        // 作ると、両者が別のものを見ていても気づけない。** 形はdirect OS observerの契約に
+        // 揃え、入力（自分のprocess・自分の木）だけを独立に観測する。
+        const checkpoint = await captureWorktreeDiff({
+          worktreePath: task.worktreePath, baseSha: task.packet.base_sha,
+        });
         const processObservationDigest = digestArtifact({
-          schema: 'lattice.scripted_process_observation.v1',
-          executor_handle: task.executorHandle,
-          state: 'stopped',
+          schema: 'lattice.direct_process_observation.v2',
+          root: {
+            pid: task.worker.pid,
+            parent_pid: process.pid,
+            process_start_identity_digest: task.worker.process_start_identity.identity_digest,
+            process_group_id: task.worker.process_group_id,
+            state: 'stopped',
+          },
+          children: [],
+          process_group_id: task.worker.process_group_id,
+          quiesced: true,
         });
         const worktreeFingerprintDigest = digestArtifact({
-          schema: 'lattice.scripted_worktree_fingerprint.v1',
+          schema: 'lattice.direct_worktree_fingerprint.v1',
           worktree_id: task.worktreeId,
-          checkpoint_digest: task.receipt.checkpoint_digest,
+          worktree_realpath: task.worktreePath,
+          checkpoint_digest: checkpoint.checkpoint_digest,
         });
-        return sign({
+        acks.push(sign({
           schema: 'lattice.executor_quiescence_ack.v1',
           ack_id: `barrier-${binding.packet_digest.slice(0, 24)}`,
           run_id: bootstrap.run_id,
@@ -668,13 +865,13 @@ export async function createScriptedAdapterController({
           packet_digest: binding.packet_digest,
           write_lease_id: binding.write_lease_id,
           barrier_control_digest: request.barrier_control_digest,
-          final_checkpoint_digest: task.receipt.checkpoint_digest,
+          final_checkpoint_digest: checkpoint.checkpoint_digest,
           process_observation_digest: processObservationDigest,
           worktree_fingerprint_digest: worktreeFingerprintDigest,
           supervisor_session_nonce_digest: sessionNonceDigest,
           ack_digest: '',
-        }, 'ack_digest');
-      });
+        }, 'ack_digest'));
+      }
       return sign({
         schema: 'lattice.adapter_barrier_response.v1',
         request_id: request.request_id,