@quolu/lattice 0.31.0 → 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.31.0",
+  "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

@@ -754,13 +754,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 +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,
           },
         };
@@ -877,37 +884,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 +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,
@@ -1810,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;
@@ -1853,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' };
@@ -1894,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();
     }
@@ -1909,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;
@@ -1928,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,
@@ -1940,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)] } }));
@@ -1970,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）。
    *
@@ -1980,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;
@@ -1987,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();
 
@@ -2115,18 +2222,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()}`,

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,7 +253,13 @@ function deterministicWriteBytes(packet, relativePath) {
   })}\n`);
 }
 
-async function executePacket({ packet, repoRoot, extraWrites = [] }) {
+/**
+ * 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)
@@ -382,6 +390,62 @@ async function readScriptedBehavior(repoRoot) {
   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,
@@ -446,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(
@@ -594,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');
       }
@@ -629,29 +701,33 @@ export async function createScriptedAdapterController({
         worktree_id: worktreeId,
         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,
+        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);
-      const worktreeReal = await realpath(worktreePath);
       task.settled = (async () => {
         try {
-          const { observedDiff, checkpointDigest } = await executePacket({
-            packet, repoRoot: worktreeReal, extraWrites: behavior.extra_writes,
-          });
-          // 書いた後も走り続ける。これが実行時観測の窓であり、0ならば窓は存在しない。
-          if (behavior.hold_ms > 0) {
-            await new Promise((resolve) => { setTimeout(resolve, behavior.hold_ms); });
-          }
+          const { observedDiff, checkpointDigest } = await spawned.completed;
           const receipt = sign({
             schema: 'lattice.executor_receipt.v1',
             receipt_id: `receipt-${packet.packet_digest.slice(0, 24)}`,
@@ -677,12 +753,13 @@ export async function createScriptedAdapterController({
         }
       })();
       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');
     }
@@ -742,24 +819,40 @@ export async function createScriptedAdapterController({
         if (task === undefined || task.packet.todo_id !== binding.todo_id) {
           fail('SCRIPTED_BARRIER_REJECTED', 'barrierが未知のrunning bindingを含む');
         }
-        // barrierは静止の宣言である。走行中の作業を残したままackを返すと、
-        // 「止まった」と言いながらworktreeが動き続ける。settleを待ってから答える。
-        if (task.settled !== null) await task.settled;
-        if (task.failure !== null) {
-          fail('SCRIPTED_BARRIER_REJECTED', 'barrier対象のworker実行が失敗している', {
-            reason: task.failure,
+        // **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,
         });
         acks.push(sign({
           schema: 'lattice.executor_quiescence_ack.v1',
@@ -772,7 +865,7 @@ 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,