@quolu/lattice 0.28.0 → 0.30.0

package/src/runtime-io-sentinel.mjs

@@ -0,0 +1,384 @@
+/**
+ * 実行時競合の早期警報（ADR 0143）。
+ *
+ * 競合はこれまで、checkpointを撮った瞬間にしか見つからなかった。checkpointに周期は無く、
+ * 実質workerが完了するまで誰も気づかない。holdで捨てる作業量の正体はこの窓である。
+ *
+ * **警報はfindingではない。** findingの契約はcheckpoint digestを必須にしており、それは
+ * findingが「事後に再読して再導出できる主張」であることを担保している。fs eventは取りこぼすし
+ * （FSEventsのcoalesce、inotifyのキュー溢れ）、事後再読もできない。よってここが出すのは
+ * 「早くcheckpointを撮って確かめろ」という引き金だけであり、判定の正本はcheckpointのままである。
+ *
+ * この非対称が安全性の根拠になる。警報は**何かを抑制することが無く、早める方向にしか働かない**。
+ * 取りこぼしても、今日と同じタイミング（完了時・hold時）で必ず捕まる——保証は一切緩まない。
+ *
+ * 判定述語はcheckpoint findingと同一（`coveredBy`を共有する）。書き込みイベントのpathから
+ * worktree rootを剥がせばrepo相対pathになり、誰がやったかはrootが決める。プロセス帰属は要らない。
+ *
+ * **ただしそれはworktreeとTODOが1対1の時だけ成り立つ。** 帰属をrootだけに預けているので、
+ * 複数TODOが同じrootを共有する構成では書き手を特定できない。そこでは監視を張らない
+ * （`syncSentinelWatches`）——見えないものを見えるふりにしない。
+ */
+
+import { watch } from 'node:fs';
+import { lstat } from 'node:fs/promises';
+import path from 'node:path';
+
+import { selfDigest } from './runtime-contracts.mjs';
+import { coveredBy } from './runtime-diff-observer.mjs';
+
+/** 警報の種別。findingのkindとは別空間にする——findingへ昇格するのはprobeを通った後だけである。 */
+export const IO_WARNING_KINDS = Object.freeze(['io_overlap_warning', 'io_scope_warning']);
+
+/**
+ * 監視から外すrepo相対prefix。
+ *
+ * `.git`と`.lattice`は道具自身の書き込みで、作業の成果ではない。`node_modules`は隔離実行が
+ * 共有mountとして張る場所であり（`seam-apply.mjs`と同じ規律）、worktreeを跨いで同じ絶対pathを
+ * 指しうるので、pathの一致を競合と読むと必ず誤る。
+ */
+export const DEFAULT_IO_EXCLUDES = Object.freeze(['.git/', '.lattice/', 'node_modules/']);
+
+const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+
+function plainRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** worktree rootを剥がしてrepo相対pathにする。rootの外を指すものはnull。 */
+export function relativeToRoot(root, absolutePath) {
+  if (typeof root !== 'string' || typeof absolutePath !== 'string') return null;
+  const relative = path.relative(root, absolutePath);
+  if (relative.length === 0) return null;
+  if (path.isAbsolute(relative) || relative.split(path.sep).includes('..')) return null;
+  return relative.split(path.sep).join('/');
+}
+
+/** 監視対象外か。prefix一致で見る。 */
+export function isExcludedPath(relativePath, excludes = DEFAULT_IO_EXCLUDES) {
+  return excludes.some((prefix) => relativePath === prefix.replace(/\/$/u, '')
+    || relativePath.startsWith(prefix));
+}
+
+/**
+ * 1件の書き込み観測を警報へ分類する。純関数。
+ *
+ * checkpoint findingの2述語をそのまま1 pathへ適用する:
+ * - 他のrunning TODOの宣言scopeに入るpathへ書いた → `io_overlap_warning`
+ * - 自分の宣言scopeの外へ書いた → `io_scope_warning`
+ *
+ * @returns {{warnings: Array<{kind: string, todo_ids: string[], path: string}>}}
+ */
+export function classifyIoObservation(options = {}) {
+  const { todoId, relativePath, packets, runningTodoIds } = options;
+  if (typeof todoId !== 'string' || typeof relativePath !== 'string'
+    || !plainRecord(packets) || !Array.isArray(runningTodoIds)) {
+    throw new TypeError('classifyIoObservation optionsが不正');
+  }
+  const packet = packets[todoId];
+  // 宣言が無いTODOの観測は判定できない。分からないものを「競合なし」へ丸めない——
+  // ただし警報は正本ではないので、ここでrunを止めることもしない。
+  if (!plainRecord(packet) || !plainRecord(packet.scope) || !Array.isArray(packet.scope.writes)) {
+    return { warnings: [] };
+  }
+
+  const warnings = [];
+  if (!coveredBy(packet.scope.writes, relativePath)) {
+    warnings.push({ kind: 'io_scope_warning', todo_ids: [todoId], path: relativePath });
+  }
+  for (const otherId of [...runningTodoIds].sort(compareText)) {
+    if (otherId === todoId) continue;
+    const other = packets[otherId];
+    if (!plainRecord(other) || !plainRecord(other.scope) || !Array.isArray(other.scope.writes)) continue;
+    if (coveredBy(other.scope.writes, relativePath)) {
+      warnings.push({
+        kind: 'io_overlap_warning',
+        todo_ids: [todoId, otherId].sort(compareText),
+        path: relativePath,
+      });
+    }
+  }
+  return { warnings };
+}
+
+/** 同じ事実を何度も報告しない。1 epochで`(kind, todo集合, path)`ごとに1回に畳む。 */
+function warningKey(warning) {
+  return `${warning.kind}\0${warning.todo_ids.join(',')}\0${warning.path}`;
+}
+
+/**
+ * running bindingのworktreeを監視し、警報を`onWarning`へ渡す。
+ *
+ * `fs.watch(root, {recursive: true})`だけを使う。Node 22の標準機能で、macOSとLinuxの双方で
+ * 動き、新しいruntime依存を持ち込まない。取りこぼしは仕様である——正本はcheckpointであり、
+ * ここは早めるためだけに在る。
+ *
+ * @param {object} options
+ * @param {Function} options.onWarning 警報1件ごとに呼ばれる。非同期でよい。
+ * @param {Function} [options.watchFactory] test用の差し替え口。既定は`fs.watch`。
+ */
+export function createIoSentinel(options = {}) {
+  const {
+    packets = {}, onWarning, excludes = DEFAULT_IO_EXCLUDES, watchFactory = watch,
+  } = options;
+  if (typeof onWarning !== 'function') throw new TypeError('onWarningが不正');
+
+  /** todo_id -> { root, watcher } */
+  const watched = new Map();
+  const reported = new Set();
+  let closed = false;
+
+  const deliver = async (todoId, relativePath, absolutePath) => {
+    if (closed) return;
+    // 実測（macOS）では、監視callbackはdirectoryイベントと、監視対象自身の名前を持つ
+    // 実在しないentryまで配ってくる。どちらもcheckpoint diffのentryにはならないので、
+    // そのまま警報にすると「警報は出たがcheckpointでは競合にならない」ずれが生まれる。
+    // 判定述語をcheckpointと揃えるために、**いま実在する通常file**だけを観測として扱う。
+    //
+    // 削除は早期警報の対象から外れる。checkpointは削除をentryとして持つので取り逃しでは
+    // なく、早く気づけないだけである——警報は早めるためだけに在るという原則どおり。
+    try {
+      const stat = await lstat(absolutePath);
+      if (!stat.isFile()) return;
+    } catch {
+      return;
+    }
+    const { warnings } = classifyIoObservation({
+      todoId, relativePath, packets, runningTodoIds: [...watched.keys()],
+    });
+    for (const warning of warnings) {
+      const key = warningKey(warning);
+      if (reported.has(key)) continue;
+      reported.add(key);
+      await onWarning(structuredClone(warning));
+    }
+  };
+
+  return {
+    /** 監視を開始する。既に同じtodoを見ているなら張り替える。 */
+    watchBinding({ todoId, worktreePath }) {
+      if (closed) return false;
+      if (typeof todoId !== 'string' || typeof worktreePath !== 'string') return false;
+      this.unwatchBinding(todoId);
+      let watcher;
+      try {
+        watcher = watchFactory(worktreePath, { recursive: true }, (_event, filename) => {
+          if (filename === null || filename === undefined) return;
+          const absolute = path.resolve(worktreePath, String(filename));
+          const relative = relativeToRoot(worktreePath, absolute);
+          if (relative === null || isExcludedPath(relative, excludes)) return;
+          // 監視callbackは同期契約なので、配送の失敗をここで投げない。
+          // 警報が落ちてもcheckpointが正本なので、runの判定は壊れない。
+          void Promise.resolve(deliver(todoId, relative, absolute)).catch(() => {});
+        });
+      } catch {
+        // 監視を張れない環境（platform制約、権限、root不在）でrunを止めない。
+        return false;
+      }
+      if (typeof watcher?.on === 'function') watcher.on('error', () => {});
+      watched.set(todoId, { root: worktreePath, watcher });
+      return true;
+    },
+
+    unwatchBinding(todoId) {
+      const entry = watched.get(todoId);
+      if (entry === undefined) return false;
+      try { entry.watcher.close(); } catch { /* 既に閉じている */ }
+      watched.delete(todoId);
+      return true;
+    },
+
+    /** epochを跨いだら減衰の記憶を捨てる。新しい版では同じpathでも改めて報告する。 */
+    resetEpoch() {
+      reported.clear();
+    },
+
+    watchedTodoIds() {
+      return [...watched.keys()].sort(compareText);
+    },
+
+    close() {
+      closed = true;
+      for (const todoId of [...watched.keys()]) this.unwatchBinding(todoId);
+      reported.clear();
+    },
+  };
+}
+
+/**
+ * running中で、かつ**書き手を特定できる**TODOだけを監視するようsentinelを合わせる（ADR 0143）。
+ *
+ * 監視rootは`executor_dispatched`の`direct_os_observation_binding.worktree_path`から取る。
+ * これがTODO→絶対pathの唯一の耐久carrierである。
+ *
+ * **rootを共有しているTODOは監視しない。** sentinelの帰属はrootだけで決まり、プロセス帰属を
+ * 持たない。同じrootで2つ以上が走っている構成では、1件の書き込みが両方のwatcherへ配られ、
+ * どちらが書いたか観測から言えない——それを警報にすると、無実のTODOへ「他人のscopeへ書いた」
+ * と主張することになる。管理daemonのscripted構成が実際にこれで、全TODOが同じrepo rootを指す。
+ *
+ * 見えないものを見えるふりにしない。共有rootでは早期警報が成立しないというだけであり、
+ * 競合の判定は従来どおりcheckpointが完全に担う——保証は1つも減らない。
+ *
+ * @param {object} options
+ * @param {object|null} options.sentinel `createRunSentinel`の戻り値
+ * @param {string[]} options.runningTodoIds いまrunningのTODO
+ * @param {Function} options.rootOf todo_id -> worktree root（未束縛はundefined）
+ */
+export function syncSentinelWatches({ sentinel, runningTodoIds, rootOf } = {}) {
+  if (sentinel === null || sentinel === undefined) return;
+  if (!Array.isArray(runningTodoIds) || typeof rootOf !== 'function') {
+    throw new TypeError('syncSentinelWatches optionsが不正');
+  }
+  const occupants = new Map();
+  for (const todoId of runningTodoIds) {
+    const root = rootOf(todoId);
+    if (typeof root !== 'string' || root.length === 0) continue;
+    occupants.set(root, (occupants.get(root) ?? 0) + 1);
+  }
+  const attributable = runningTodoIds.filter((todoId) => occupants.get(rootOf(todoId)) === 1);
+  const watched = new Set(sentinel.watchedTodoIds());
+  for (const todoId of watched) {
+    if (!attributable.includes(todoId)) sentinel.unwatchBinding(todoId);
+  }
+  for (const todoId of attributable) {
+    // 張り替えは監視を一度落とすので、既に見ているものへは触らない。
+    if (watched.has(todoId)) continue;
+    sentinel.watchBinding({ todoId, worktreePath: rootOf(todoId) });
+  }
+}
+
+/** `LATTICE_IO_SENTINEL`の解釈。既定は警報を出す。`off`で完全に無効。 */
+export function ioSentinelMode(env = process.env) {
+  const raw = String(env.LATTICE_IO_SENTINEL ?? '').trim().toLowerCase();
+  return ['off', 'warn'].includes(raw) ? raw : 'warn';
+}
+
+/**
+ * run用のsentinelを作る。無効なら`null`を返す——呼び出し側は分岐を1つ持つだけでよい。
+ *
+ * 監視を張れない環境でrunを止めないのと同じ理由で、ここで例外を投げない。sentinelは
+ * 速さのための付加物であり、これが無くてもrunの判定は今までどおり成立する。
+ */
+export function createRunSentinel({ packets, onWarning, env = process.env } = {}) {
+  if (ioSentinelMode(env) === 'off') return null;
+  return createIoSentinel({ packets, onWarning });
+}
+
+/**
+ * 警報が実在の重なりだったかをcheckpointで確かめる（ADR 0143の二段目）。
+ *
+ * 警報だけで止めると、書いて消したtempでも全workerを止めてしまう。かといって警報を
+ * findingへ昇格させることもできない——findingは事後に再読して再導出できる主張でなければ
+ * ならず、fs eventはそれを満たさない。
+ *
+ * よって間に**probe**を挟む。関与worktreeを無停止でcheckpointし、当該pathがdiffに
+ * 残っていれば実在、消えていればtransientとする。probeが撮ったcheckpointはgitから読んだ
+ * 本物のdiffなので、そのままfindingの証拠になる——契約を1つも緩めずに済む。
+ *
+ * @param {object} options
+ * @param {object} options.warning `classifyIoObservation`が返した警報
+ * @param {object} options.checkpointsByTodo todo_id -> `captureWorktreeDiff`の戻り値
+ * @returns {{outcome: 'observed'|'transient', writers: string[]}}
+ */
+export function probeIoWarning({ warning, checkpointsByTodo } = {}) {
+  if (!plainRecord(warning) || typeof warning.path !== 'string'
+    || !Array.isArray(warning.todo_ids) || !plainRecord(checkpointsByTodo)) {
+    throw new TypeError('probeIoWarning optionsが不正');
+  }
+  const writers = [];
+  for (const todoId of [...warning.todo_ids].sort(compareText)) {
+    const entries = checkpointsByTodo[todoId]?.diff?.entries;
+    if (!Array.isArray(entries)) continue;
+    if (entries.some((entry) => entry?.path === warning.path)) writers.push(todoId);
+  }
+  // 重なりを主張する警報は、当該pathが**実際に変更として残っている**ことを要件にする。
+  // scope警報は自分1人の話なので、自分のdiffに残っていれば実在である。
+  const required = warning.kind === 'io_overlap_warning' ? 2 : 1;
+  return { outcome: writers.length >= required ? 'observed' : 'transient', writers };
+}
+
+/**
+ * 警報kind → finding kind。probeを通った警報だけがこの写像に乗る。
+ *
+ * 述語が同一（`coveredBy`）なので、写像は1対1に決まる。ここで新しい種類を発明しない——
+ * 発明すると、警報経由のfindingだけ既存の処置（請求項7の直列化、請求項8のseam変換）が
+ * 効かない種類になってしまう。
+ */
+const WARNING_FINDING_KIND = Object.freeze({
+  io_overlap_warning: 'observed_write_conflict',
+  io_scope_warning: 'scope_violation',
+});
+
+/**
+ * findingを縛るcheckpointの持ち主を選ぶ。
+ *
+ * scope警報は自分1人の話なので当人。重なりは**他人の宣言scopeへ書いた側**——producerの
+ * 述語がそう定義されているからで、ここで別の選び方をすると再導出が一致しない。
+ * 双方が同じpathを宣言している場合は両方が資格を持つので、昇順で決めて揺らさない。
+ */
+function selectEscalationAnchor({ warning, writers, packets }) {
+  const wrote = new Set(writers);
+  const qualified = [...warning.todo_ids].sort(compareText).filter((todoId) => {
+    if (!wrote.has(todoId)) return false;
+    if (warning.kind === 'io_scope_warning') return true;
+    return warning.todo_ids.some((otherId) => {
+      if (otherId === todoId) return false;
+      const other = packets[otherId];
+      return plainRecord(other) && plainRecord(other.scope) && Array.isArray(other.scope.writes)
+        && coveredBy(other.scope.writes, warning.path);
+    });
+  });
+  return qualified[0] ?? null;
+}
+
+/**
+ * probeを通った警報を、既存のhold経路が受け取れるfinding candidateへ写す（ADR 0143の三段目）。
+ *
+ * **新しい判定はここに1つも無い。** 出すのはcandidate——つまり「主張」だけであり、それを
+ * findingへ昇格させてよいかは既存の`finding_record`が再導出して決める。だから早期警報が
+ * 短くするのは気づくまでの時間だけで、通す関門は1つも減らない。
+ *
+ * findingは1つのcheckpointへ縛られるので、**anchorの選び方が効く**。`detectCheckpointFindings`は
+ * anchorのdiffと「他TODOの宣言write」からしか重なりを導かないので、anchorは
+ * **他人の宣言scopeへ書いた側（offender）**でなければならない。警報自身は`todo_ids`を
+ * 昇順一意で持つ設計上どちらがofferedかを覚えていないので、ここで宣言から選び直す。
+ * 選び間違えるとproducerが同じfindingを再導出できず、正しい警報が形式の都合で落ちる。
+ *
+ * @param {object} options
+ * @param {object} options.warning `classifyIoObservation`が返した警報
+ * @param {object} options.probe `probeIoWarning`が返した判定
+ * @param {object} options.checkpointsByTodo todo_id -> `captureWorktreeDiff`の戻り値
+ * @param {object} options.packets todo_id -> executor packet（宣言scopeの出所）
+ * @returns {null|{anchor_todo_id: string, checkpoint_digest: string, writers: string[], candidate: object}}
+ */
+export function buildIoEscalation({ warning, probe, checkpointsByTodo, packets } = {}) {
+  if (!plainRecord(warning) || !plainRecord(probe) || !plainRecord(checkpointsByTodo)
+    || !plainRecord(packets) || !Array.isArray(probe.writers)) {
+    throw new TypeError('buildIoEscalation optionsが不正');
+  }
+  if (probe.outcome !== 'observed') return null;
+  const proposedKind = WARNING_FINDING_KIND[warning.kind];
+  if (proposedKind === undefined) return null;
+  const anchorTodoId = selectEscalationAnchor({ warning, writers: probe.writers, packets });
+  if (anchorTodoId === null) return null;
+  const checkpoint = checkpointsByTodo[anchorTodoId];
+  if (!plainRecord(checkpoint) || !/^[0-9a-f]{64}$/u.test(checkpoint.checkpoint_digest ?? '')) {
+    return null;
+  }
+  const candidate = {
+    schema: 'lattice.runtime_finding_candidate.v1',
+    proposed_kind: proposedKind,
+    todo_ids: [...warning.todo_ids].sort(compareText),
+    path: warning.path,
+    resource_id: null,
+    evidence_digests: [checkpoint.checkpoint_digest],
+    candidate_digest: '',
+  };
+  candidate.candidate_digest = selfDigest(candidate, 'candidate_digest');
+  return {
+    anchor_todo_id: anchorTodoId,
+    checkpoint_digest: checkpoint.checkpoint_digest,
+    writers: [...probe.writers].sort(compareText),
+    candidate,
+  };
+}

package/src/runtime-managed-supervisor.mjs

@@ -8,6 +8,7 @@ import { promisify } from 'node:util';
 import { canonicalizeArtifact, digestArtifact } from './artifact-contracts.mjs';
 import { selfDigest } from './runtime-contracts.mjs';
 import { captureWorktreeDiff } from './runtime-diff-observer.mjs';
+import { pidsOwningSocketPath, socketPathsOwnedByPid } from './runtime-socket-owner.mjs';
 import { createDirectOsProcessObserver as createDirectOsProcessObserverV2 } from './runtime-direct-os-observer.mjs';
 import {
   armStagedWriteLease,
@@ -877,10 +878,10 @@ async function activateManagedSupervisorController({ repoRoot, runDir, runId, ad
       }
       const endpointInfo = await lstat(handshakeSocket);
       if (!endpointInfo.isSocket() || endpointInfo.isSymbolicLink()) fail('ADAPTER_LAUNCH_INVALID', 'existing endpointがsocketでない');
-      let ownerOutput;
-      try { ({ stdout: ownerOutput } = await execFileAsync('/usr/sbin/lsof', ['-t', handshakeSocket], { encoding: 'utf8' })); }
+      let ownerPids;
+      try { ownerPids = await pidsOwningSocketPath(handshakeSocket); }
       catch { fail('ADAPTER_LAUNCH_INVALID', 'existing endpoint ownerを観測できない'); }
-      endpointOwnerPids = new Set(ownerOutput.trim().split(/\s+/u).filter(Boolean).map(Number));
+      endpointOwnerPids = new Set(ownerPids);
       if (endpointOwnerPids.size !== 1 || [...endpointOwnerPids].some((pid) => !Number.isSafeInteger(pid) || pid < 1)) {
         fail('ADAPTER_LAUNCH_INVALID', 'existing endpoint ownerが一意でない');
       }
@@ -900,10 +901,10 @@ async function activateManagedSupervisorController({ repoRoot, runDir, runId, ad
         try { if ((await lstat(controllerSocketPath)).isSocket()) break; } catch (error) { if (error?.code !== 'ENOENT') throw error; }
         await new Promise((resolve) => setTimeout(resolve, 20));
       }
-      let controllerOwnerOutput;
-      try { ({ stdout: controllerOwnerOutput } = await execFileAsync('/usr/sbin/lsof', ['-t', controllerSocketPath], { encoding: 'utf8' })); }
+      let controllerOwnerPids;
+      try { controllerOwnerPids = await pidsOwningSocketPath(controllerSocketPath); }
       catch { fail('ADAPTER_CONTROLLER_UNAVAILABLE', 'existing controller socket ownerを観測できない'); }
-      const persistentOwners = new Set(controllerOwnerOutput.trim().split(/\s+/u).filter(Boolean).map(Number));
+      const persistentOwners = new Set(controllerOwnerPids);
       if (persistentOwners.size !== 1 || !persistentOwners.has(controllerDescriptor.pid)) {
         fail('ADAPTER_CONTROLLER_UNAVAILABLE', 'persistent controller socket ownerとdescriptor PID不一致');
       }
@@ -1019,12 +1020,10 @@ export async function sendRuntimeControlRequest({ socketPath, request, timeoutMs
   try { observedSupervisor = await observeManagedProcessStartIdentity(descriptor.pid); }
   catch { fail('RUN_NOT_MANAGED', 'supervisor process不在'); }
   if (canonicalizeArtifact(observedSupervisor) !== canonicalizeArtifact(descriptor.process_start_identity)) fail('RUN_NOT_MANAGED', 'supervisor PID/start identity不一致');
-  let lsofOutput;
-  try {
-    ({ stdout: lsofOutput } = await execFileAsync('/usr/sbin/lsof', ['-a', '-p', String(descriptor.pid), '-U', '-F', 'fn'], { encoding: 'utf8' }));
-  } catch { fail('RUN_NOT_MANAGED', 'supervisor socket owner観測失敗'); }
-  const ownsExactSocket = lsofOutput.split('\n')
-    .filter((line) => line.startsWith('n')).map((line) => line.slice(1))
+  let ownedSocketPaths;
+  try { ownedSocketPaths = await socketPathsOwnedByPid(descriptor.pid); }
+  catch { fail('RUN_NOT_MANAGED', 'supervisor socket owner観測失敗'); }
+  const ownsExactSocket = ownedSocketPaths
     .some((name) => name === absoluteSocket || name === socketRef);
   if (!ownsExactSocket) fail('RUN_NOT_MANAGED', 'supervisor PIDがcontrol socket inodeを所有しない');
   return new Promise((resolve, reject) => {
@@ -1088,10 +1087,10 @@ export async function sendRuntimeActivationRequest({ socketPath, request, expect
   try { observedBootstrapIdentity = await observeManagedProcessStartIdentity(expectedPid); }
   catch { fail('RUN_NOT_MANAGED', 'activation bootstrap process不在'); }
   if (canonicalizeArtifact(observedBootstrapIdentity) !== canonicalizeArtifact(expectedProcessStartIdentity)) fail('RUN_NOT_MANAGED', 'activation bootstrap PID/start identity不一致');
-  let lsofOutput;
-  try { ({ stdout: lsofOutput } = await execFileAsync('/usr/sbin/lsof', ['-a', '-p', String(expectedPid), '-U', '-F', 'fn'], { encoding: 'utf8' })); }
+  let bootstrapSocketPaths;
+  try { bootstrapSocketPaths = await socketPathsOwnedByPid(expectedPid); }
   catch { fail('RUN_NOT_MANAGED', 'activation socket owner観測失敗'); }
-  if (!lsofOutput.split('\n').filter((line) => line.startsWith('n')).map((line) => line.slice(1))
+  if (!bootstrapSocketPaths
     .some((name) => name === absoluteSocket || name === socketRef)) fail('RUN_NOT_MANAGED', 'bootstrap PIDがcontrol socketを所有しない');
   const originalCwd = process.cwd();
   process.chdir(runDir);
@@ -1143,13 +1142,15 @@ export async function prepareManagedSupervisorRestart({ runDir }) {
   const socketInfo = await lstat(socketPath).catch(() => null);
   if (socketInfo !== null) {
     if (!socketInfo.isSocket() || socketInfo.isSymbolicLink()) fail('RUN_NOT_MANAGED', 'stale socket path差替え');
-    try {
-      const { stdout } = await execFileAsync('/usr/sbin/lsof', [socketPath], { encoding: 'utf8' });
-      if (stdout.trim().length > 0) fail('RUN_BUSY', 'control socketは別processが所有中');
-    } catch (error) {
+    // 所有者が居るなら消さない。観測できなければ「誰も居ない」へ丸めず観測失敗として止める
+    // （lsofはヒット無しでexit 1を返すので、この2つを区別する必要がある）。
+    let staleOwners;
+    try { staleOwners = await pidsOwningSocketPath(socketPath); }
+    catch (error) {
       if (error instanceof ManagedRuntimeError) throw error;
-      if (!(error?.code === 1 && String(error?.stdout ?? '').trim() === '')) fail('RUN_NOT_MANAGED', 'stale socket owner観測失敗');
+      fail('RUN_NOT_MANAGED', 'stale socket owner観測失敗');
     }
+    if (staleOwners.length > 0) fail('RUN_BUSY', 'control socketは別processが所有中');
     await rm(socketPath, { force: true });
   }
   return { previousDescriptorDigest: descriptor.descriptor_digest };
@@ -1220,13 +1221,13 @@ export async function serveRuntimeControlSocket({ socketPath, handler }) {
   try {
     const existing = await lstat(socketPath);
     if (!existing.isSocket()) fail('RUN_NOT_MANAGED', 'control.sockがsocketでない');
-    try {
-      const { stdout } = await execFileAsync('/usr/sbin/lsof', [socketPath], { encoding: 'utf8' });
-      if (stdout.trim().length > 0) fail('RUN_BUSY', 'control.sockはlive processが所有する');
-    } catch (error) {
+    let liveOwners;
+    try { liveOwners = await pidsOwningSocketPath(socketPath); }
+    catch (error) {
       if (error instanceof ManagedRuntimeError) throw error;
-      if (!(error?.code === 1 && String(error?.stdout ?? '').trim() === '')) fail('RUN_NOT_MANAGED', 'control.sock owner観測失敗');
+      fail('RUN_NOT_MANAGED', 'control.sock owner観測失敗');
     }
+    if (liveOwners.length > 0) fail('RUN_BUSY', 'control.sockはlive processが所有する');
     await rm(socketPath, { force: true });
   } catch (error) {
     if (error?.code !== 'ENOENT') throw error;

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

@@ -31,6 +31,7 @@ import {
 } from './runtime-contracts.mjs';
 import { validateSupervisorWriteGate } from './runtime-gate-store.mjs';
 import { observeManagedProcessStartIdentity } from './runtime-managed-supervisor.mjs';
+import { scriptedWorktreeId, scriptedWorktreePath } from './runtime-scripted-worktree.mjs';
 
 const MAX_DOCUMENT_BYTES = 8_388_608;
 const SHA256 = /^[0-9a-f]{64}$/u;
@@ -538,12 +539,24 @@ export async function createScriptedAdapterController({
         }, 'response_digest');
       }
       await readAndValidateGate(canonicalRunDir, writeLease);
+      // canonical repoではなく自分の木へ書く。共有rootでは、書き込みの帰属をrootから
+      // 決められないので早期警報もcheckpoint判定も成立しない。木はsupervisorが
+      // dispatch前に用意する（監視を張るのがdispatchより前でなければ観測を取り逃す）。
+      const worktreePath = scriptedWorktreePath({ runDir: canonicalRunDir, packet });
+      try {
+        const info = await lstat(worktreePath);
+        if (!info.isDirectory()) throw new TypeError('not a directory');
+      } catch {
+        fail('SCRIPTED_EXECUTION_FAILED', 'supervisorが用意したworktreeが無い', {
+          worktree_path: worktreePath,
+        });
+      }
       const { observedDiff, checkpointDigest } = await executePacket({
         packet,
-        repoRoot: canonicalRepoRoot,
+        repoRoot: await realpath(worktreePath),
       });
       const executorHandle = `scripted-${packet.packet_digest.slice(0, 24)}`;
-      const worktreeId = `scripted-wt-${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)}`,

package/src/runtime-scripted-worktree.mjs

@@ -0,0 +1,104 @@
+/**
+ * 管理runtimeのworker worktree配置（ADR 0143 / io-sentinel st-004）。
+ *
+ * **なぜ配置を契約にするのか。** supervisor daemonとscripted controllerは別プロセスであり、
+ * 両者が同じ木を指す必要がある。daemonは「どこを監視し、どこのdiffを撮るか」を知らなければ
+ * ならず、controllerは「どこへ書くか」を知らなければならない。dispatch応答は`worktree_id`しか
+ * 運ばないので、pathを応答へ足すか、配置そのものを契約にするかの二択になる。ここでは後者を採る
+ * ——**daemonが監視を張れるのはdispatchの前**であり、応答を待っていては書き込みを取り逃すからである。
+ *
+ * これが無かった頃、全TODOのbindingは同じrepo rootを指していた。sentinelの帰属はrootだけで
+ * 決まるので、共有rootでは誰が書いたかを言えず、早期警報は成立しなかった。checkpoint判定も
+ * 同じ理由で帰属を決められない。**worktreeとTODOの1対1は、装置の前提であって最適化ではない。**
+ */
+
+import { spawn } from 'node:child_process';
+import { mkdir, realpath, rm } from 'node:fs/promises';
+import path from 'node:path';
+
+const GIT_SHA1 = /^[0-9a-f]{40}$/u;
+
+function fail(reason) {
+  throw new TypeError(`scripted worktree契約違反: ${reason}`);
+}
+
+function run(command, args, cwd, { allowExitCodes = [0] } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on('data', (chunk) => stdout.push(chunk));
+    child.stderr.on('data', (chunk) => stderr.push(chunk));
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      if (allowExitCodes.includes(code) && signal === null) {
+        resolve(Object.assign(Buffer.concat(stdout), { code }));
+      } else {
+        reject(new TypeError(
+          `${command} ${args[0]} failed (${signal ?? code}): ${Buffer.concat(stderr).toString('utf8').trim()}`,
+        ));
+      }
+    });
+  });
+}
+
+/** worktreeの名前。packet digestへ縛るので、同じpacketには必ず同じ木が対応する。 */
+export function scriptedWorktreeId(packet) {
+  const digest = packet?.packet_digest;
+  if (typeof digest !== 'string' || !/^[0-9a-f]{64}$/u.test(digest)) {
+    fail('packet_digestが不正');
+  }
+  return `scripted-wt-${digest.slice(0, 24)}`;
+}
+
+/** run store配下のworktree path。runの寿命と一致するので、後片付けもrunに閉じる。 */
+export function scriptedWorktreePath({ runDir, packet } = {}) {
+  if (typeof runDir !== 'string' || runDir.length === 0) fail('runDirが不正');
+  return path.join(runDir, 'worktrees', scriptedWorktreeId(packet), 'tree');
+}
+
+/**
+ * packetのbase shaでworktreeを用意する。既に在るなら作り直さない。
+ *
+ * run storeはgitignore済みなので（`requireIgnoredRunStore`）、ここに木を切っても
+ * canonical repoの`git status`は汚れない。
+ */
+export async function ensureScriptedWorktree({ repoRoot, runDir, packet } = {}) {
+  if (typeof repoRoot !== 'string' || repoRoot.length === 0) fail('repoRootが不正');
+  if (!GIT_SHA1.test(packet?.base_sha ?? '')) fail('packet.base_shaが不正');
+  const worktreePath = scriptedWorktreePath({ runDir, packet });
+  try {
+    return await realpath(worktreePath);
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+  await mkdir(path.dirname(worktreePath), { recursive: true, mode: 0o700 });
+  await run('git', ['worktree', 'add', '--detach', worktreePath, packet.base_sha], repoRoot);
+  return realpath(worktreePath);
+}
+
+/**
+ * runが持つworktreeを全て畳む。
+ *
+ * 取り残すと`git worktree list`へ積み上がり、次のrunがprune前提の状態を引き継ぐ。
+ * 失敗は握り潰さず、畳めなかったpathを添えて返す——呼び出し側が記録できる形にしておく。
+ */
+export async function removeScriptedWorktrees({ repoRoot, runDir } = {}) {
+  if (typeof repoRoot !== 'string' || repoRoot.length === 0) fail('repoRootが不正');
+  if (typeof runDir !== 'string' || runDir.length === 0) fail('runDirが不正');
+  const root = path.join(runDir, 'worktrees');
+  const listed = await run('git', ['worktree', 'list', '--porcelain'], repoRoot);
+  const residual = [];
+  for (const line of listed.toString('utf8').split('\n')) {
+    if (!line.startsWith('worktree ')) continue;
+    const target = line.slice('worktree '.length);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) continue;
+    try {
+      await run('git', ['worktree', 'remove', '--force', target], repoRoot);
+    } catch {
+      residual.push(target);
+    }
+  }
+  if (residual.length === 0) await rm(root, { recursive: true, force: true });
+  return { removed_root: root, residual_paths: residual };
+}