@quolu/lattice 0.31.0 → 0.33.0

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,28 @@ export async function createScriptedAdapterController({
   let currentEpoch = 1;
   let registrationDigest = null;
 
+  /** dispatch応答が運ぶworker process。誰を止めればよいかをsupervisorへ名指しする。 */
+  /**
+   * 起こしたworker processを畳む。
+   *
+   * **SIGKILLでなければ届かない。** barrierで止めたworkerはSIGSTOP状態にあり、
+   * SIGTERMは継続されるまで配送されない。放置すると、runもcontrollerもrepoも消えた後まで
+   * 停止したままのprocessが残り続ける（自分では終われない）。
+   */
+  const reapWorkers = () => {
+    for (const task of tasks.values()) {
+      const pid = task.worker?.pid;
+      if (!Number.isSafeInteger(pid)) continue;
+      try { process.kill(pid, 'SIGKILL'); } catch { /* 既に終わっている */ }
+    }
+  };
+
+  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 +680,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 +716,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 +768,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 +834,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 +880,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,
@@ -811,7 +919,9 @@ export async function createScriptedAdapterController({
         worktree_id: rebind.worktree_id,
         predecessor_epoch: rebind.new_plan_epoch - 1,
         successor_epoch: rebind.new_plan_epoch,
-        predecessor_packet_digest: task.receipt.packet_digest,
+        // **holdされたworkerにreceiptは無い。** 作業を終えていないから止められているので、
+        // 完了の記録を前提にできない。前任packetのdigestはdispatch時のpacketが持っている。
+        predecessor_packet_digest: task.packet.packet_digest,
         rebind_packet_digest: rebind.packet_digest,
         new_write_lease_id: staged.lease_id,
         supervisor_session_nonce_digest: sessionNonceDigest,
@@ -854,6 +964,7 @@ export async function createScriptedAdapterController({
     controllerSessionNonce,
     descriptor: structuredClone(descriptor),
     heartbeat,
+    reapWorkers,
     leaseSetDigest() {
       return digestArtifact([...stagedLeases.keys(), ...armedLeases.keys()].sort());
     },
@@ -1009,6 +1120,9 @@ export async function runScriptedAdapterController({
   const close = async () => {
     if (closed) return;
     closed = true;
+    // 起こしたworkerを道連れにする。停止中のworkerは自分では終われないので、
+    // ここで畳まないとrunもrepoも消えた後まで残り続ける。
+    controller.reapWorkers();
     clearInterval(heartbeatTimer);
     persistentSocket?.destroy();
     await new Promise((resolve) => server.close(resolve));

package/src/runtime-seam-resolve.mjs

@@ -19,11 +19,16 @@ import { digestArtifact } from './artifact-contracts.mjs';
 import { commitSeamTransform } from './seam-commit.mjs';
 import { applySeamConflict } from './seam-apply.mjs';
 import { resolveRuntimeSeamTreatment } from './runtime-seam-treatment.mjs';
+import { affectedTestsFromEvidence } from './runtime-front-end.mjs';
+import { explainSeamGate } from './seam-gate.mjs';
 import { collectWitnessSensorEvidence, compileTodoIndependence } from './todo-independence.mjs';
 import { todoSelfDigest } from './todo-contracts.mjs';
 
 export const RUNTIME_SEAM_REQUEST_SCHEMA = 'lattice.runtime_seam_request.v1';
-export const RUNTIME_SEAM_RESOLUTION_SCHEMA = 'lattice.runtime_seam_resolution.v1';
+// v2は翻訳段（`reconciled`）の追加である。宣言を観測へ合わせてから判定するようになったので、
+// どの宣言の上で五条件を見たかが決着の一部になった。v1の形のまま中身を変えると、記録が何に
+// ついてのものか確定しなくなる。
+export const RUNTIME_SEAM_RESOLUTION_SCHEMA = 'lattice.runtime_seam_resolution.v2';
 
 /** 合成するtodo planのkey。実行時planとは別空間なので固定でよい。 */
 const SYNTHETIC_PLAN_KEY = 'runtime';
@@ -77,21 +82,130 @@ export function validateRuntimeSeamRequest(value) {
   return value.request_digest === todoSelfDigest(value, 'request_digest');
 }
 
+/**
+ * 観測された実態へ宣言を合わせる（翻訳段）。
+ *
+ * 実行時のpath競合は、**片方がその資源を所有していないから起きる**。所有していない資源の内側に
+ * 担当は主張できない（`concern_anchor_resource_not_owned`）ので、宣言のままでは変換の入力が
+ * 組めない——請求項8は、実行時に見つかった競合の形をそのままでは受け取れなかった。
+ *
+ * 境界は計画時の**予測**であって、workerを閉じ込める制約ではない。予測を超えたのは予測が狭かった
+ * からであり、作業が不正だったからではない。したがって操作は「破った側を直す」ではなく、観測が
+ * 示した実態へ宣言を合わせることであり、**対称**である——どちらの足跡が予測を超えたかは観測が
+ * 決めるので、ここでは関与TODOを同じ規則で扱う。
+ *
+ * これは3つ目の処置ではない。翻訳を通ると計画時競合の形（`owns`の交差）になり、そこから先は
+ * 既存の請求項7／8がそのまま適用できる。競合辺が立つのは翻訳の副産物ではなく目的である——
+ * 立たないままだと`overlap_reduced`が最初から満たされたことになり、変換の検証が無意味になる。
+ *
+ * 広げるのは観測が示した資源だけとする。findingが持つ係争pathも関与TODOも観測であって推定では
+ * ない。広げた事実は呼び出し側へ返す。黙って広げると、予測が外れたことも、判定がどの宣言の上で
+ * 行われたかも残らない。
+ *
+ * **所有の宣言は裏取りと対で広げる。** `owns`だけ足すとその資源は`sensor_unbound`になり、compileは
+ * 非dispatchable（`BOUNDARY_UNKNOWN`）へ落ちる。そこでは競合が投影されないので、翻訳したのに
+ * 競合辺が立たず、変換の便益が測れない。裏取りに使えるqueryがrun のquery setに無ければ、
+ * 広げずに理由を返す——証明できない宣言を作らない。
+ */
+export function reconcileWitnessToObservation({
+  manualWitness, contestedPath, todoIds, sensorQuerySet = null, observedAffectedTests = null,
+} = {}) {
+  const reconciled = {};
+  const widened = [];
+  const reject = (reason) => ({ manualWitness: null, widened: [], reasons: [reason] });
+  // 係争pathを覆えるqueryを、run のquery setから拾う。無ければ翻訳しない。
+  //
+  // `affected`だけを見る。path所有を裏取りするのはこのoperationであり、構造query（query／callers／
+  // callees／impact）はsymbolを的にする。構造queryがたまたま同じ文字列をtargetに持つからといって
+  // 所有の裏取りへ流用すると、束縛の意味が変わる。
+  const covering = (sensorQuerySet?.queries ?? [])
+    .filter((query) => query.operation === 'affected' && query.target === contestedPath)
+    .map((query) => query.id)
+    .sort(compareText);
+
+  for (const todoId of todoIds) {
+    const witness = manualWitness?.[todoId];
+    if (!plainObject(witness)) return reject(`witness_absent:${todoId}`);
+    const next = structuredClone(witness);
+    const ownsPath = (next.owns ?? [])
+      .some((own) => own.kind === 'path' && own.target === contestedPath);
+    const writesPath = (next.writes ?? []).includes(contestedPath);
+    const boundPath = (next.sensor_provenance?.queries ?? [])
+      .some((entry) => (entry.expect?.kind === 'affected' || entry.expect?.kind === 'path')
+        && entry.expect?.path === contestedPath);
+    // 既に所有と書き込みを宣言しているなら、観測は予測の内側にある。合わせるものが無いので
+    // 触らない——裏取りが足りているかどうかは、その宣言を書いた側の問題であり、compileが見る。
+    // 翻訳が手を入れてよいのは、観測が予測を超えた分だけである。
+    if (ownsPath && writesPath) {
+      reconciled[todoId] = next;
+      continue;
+    }
+    if (!boundPath) {
+      if (covering.length === 0) return reject(`observation_unbacked:${todoId}:${contestedPath}`);
+      // 同じ資源は同じqueryで裏取りする。TODOごとに別のqueryを選ぶと、front-endが被覆の
+      // 曖昧さとして弾く。
+      if (covering.length > 1) return reject(`observation_binding_ambiguous:${contestedPath}`);
+      // 観測できていないaffectedを推測で埋めない。
+      if (!Array.isArray(observedAffectedTests)) {
+        return reject(`observation_affected_unread:${contestedPath}`);
+      }
+    }
+    // 所有・書き込み・裏取りをまとめて足す。観測されたのは「このpathへの書き込み」であり、
+    // 宣言の一部だけを合わせると、宣言が実態からずれたまま次の判定の前提になる。`creates`は
+    // 付けない——観測できたのはpathが既に在るからである。
+    if (!ownsPath) next.owns = [...next.owns, { kind: 'path', target: contestedPath }]
+      .sort((left, right) => compareText(`${left.kind}\0${left.target}`, `${right.kind}\0${right.target}`));
+    if (!writesPath) next.writes = [...next.writes, contestedPath].sort(compareText);
+    if (!boundPath) {
+      next.sensor_provenance = {
+        ...next.sensor_provenance,
+        queries: [...next.sensor_provenance.queries,
+          { query_id: covering[0], expect: { kind: 'affected', path: contestedPath } }],
+      };
+      // 面を1つ引き受けたら、その面のaffected testも引き受ける。宣言と観測はTODO単位で
+      // exact一致を要求されるので、片方だけ広げるとdriftになる。
+      next.affected_tests = [...new Set([...next.affected_tests, ...observedAffectedTests])]
+        .sort(compareText);
+    }
+    reconciled[todoId] = next;
+    widened.push({
+      todo_id: todoId,
+      resource: { kind: 'path', target: contestedPath },
+      fields: [
+        ...(ownsPath ? [] : ['owns']),
+        ...(writesPath ? [] : ['writes']),
+        ...(boundPath ? [] : ['affected_tests', 'sensor_provenance']),
+      ].sort(compareText),
+    });
+  }
+  return { manualWitness: reconciled, widened, reasons: [] };
+}
+
 /**
  * 実行時witnessへconcern anchorを足してtodo witness setにする。
  *
  * 実行時のmanual_witnessはconcern_anchorsを持たない（`lattice.run_request.v3`）。持たせるのでなく、
  * 宣言から足す——係争資源の中のどのsymbolを触るかは実行時に確定する情報であり、run開始時点の
  * 契約に書けるものではないからである。
+ *
+ * anchorを足す前に宣言を観測へ合わせる（`reconcileWitnessToObservation`）。この順序でないと、
+ * 係争資源を所有していないTODOのanchorが必ず不正になる。
  */
-export function buildRuntimeSeamWitnessSet({ request, declaration, contestedPath, executors }) {
+export function buildRuntimeSeamWitnessSet({
+  request, declaration, contestedPath, executors, observedAffectedTests = null,
+}) {
   const todoIds = Object.keys(declaration.concern_symbols).sort(compareText);
+  const translated = reconcileWitnessToObservation({
+    manualWitness: request.manual_witness, contestedPath, todoIds,
+    sensorQuerySet: request.sensor_query_set, observedAffectedTests,
+  });
+  if (translated.manualWitness === null) {
+    return { witnessSet: null, widened: [], reasons: translated.reasons };
+  }
   const manual = {};
   for (const todoId of todoIds) {
-    const witness = request.manual_witness?.[todoId];
-    if (!plainObject(witness)) return { witnessSet: null, reasons: [`witness_absent:${todoId}`] };
     manual[todoId] = {
-      ...structuredClone(witness),
+      ...translated.manualWitness[todoId],
       concern_anchors: [{
         within: { kind: 'path', target: contestedPath },
         symbols: [...declaration.concern_symbols[todoId]].sort(compareText),
@@ -108,7 +222,7 @@ export function buildRuntimeSeamWitnessSet({ request, declaration, contestedPath
     witness_set_digest: '',
   };
   witnessSet.witness_set_digest = todoSelfDigest(witnessSet, 'witness_set_digest');
-  return { witnessSet, reasons: [] };
+  return { witnessSet, widened: translated.widened, reasons: [] };
 }
 
 function syntheticTodoPlan(todoIds) {
@@ -137,7 +251,7 @@ export async function resolveRuntimeSeam({
   const todoIds = Object.keys(declaration.concern_symbols).sort(compareText);
 
   if (finding.kind !== 'observed_write_conflict' || typeof finding.path !== 'string') {
-    return { lane: 'intentional_serial', reasons: ['finding_not_write_conflict'], split: null };
+    return { lane: 'intentional_serial', reasons: ['finding_not_write_conflict'], split: null, widened: [] };
   }
   const findingTodoIds = [...finding.todo_ids].sort(compareText);
   if (findingTodoIds.join('\0') !== todoIds.join('\0')) {
@@ -145,30 +259,41 @@ export async function resolveRuntimeSeam({
       lane: 'intentional_serial',
       reasons: ['declared_todos_differ_from_finding'],
       split: null,
+      widened: [],
     };
   }
 
+  // sensorは1回だけ引く。翻訳（宣言を観測へ合わせる）とcompileは同じ観測の上で行う——
+  // 別々に引くと、翻訳が見た実態とcompileが見た実態がずれうる。
+  const sensorEvidence = await collectWitnessSensorEvidence({
+    cwd: repoRoot, witnessSet: { sensor_query_set: request.sensor_query_set },
+  });
   const built = buildRuntimeSeamWitnessSet({
     request, declaration, contestedPath: finding.path,
     executors: request.capacity.executors,
+    observedAffectedTests: affectedTestsFromEvidence({
+      sensorEvidence, querySet: request.sensor_query_set, path: finding.path,
+    }),
   });
   if (built.witnessSet === null) {
-    return { lane: 'intentional_serial', reasons: built.reasons, split: null };
+    return { lane: 'intentional_serial', reasons: built.reasons, split: null, widened: [] };
   }
   const witnessSet = built.witnessSet;
   const plan = syntheticTodoPlan(todoIds);
 
-  // 観測したaffected testsだけを検証に使う。宣言から発明しない。
+  // 観測したaffected testsだけを検証に使う。宣言から発明しない。翻訳後の宣言から採る——
+  // 所有が広がったTODOは、その面のtestも自分のaffectedとして引き受けている。
   const affectedTests = [...new Set(todoIds
-    .flatMap((todoId) => request.manual_witness[todoId].affected_tests))].sort(compareText);
+    .flatMap((todoId) => witnessSet.manual_witness[todoId].affected_tests))].sort(compareText);
 
   const baseArtifact = compileTodoIndependence({
-    witnessSet, plan, baseSha, compiledAt,
-    sensorEvidence: await collectWitnessSensorEvidence({ cwd: repoRoot, witnessSet }),
+    witnessSet, plan, baseSha, compiledAt, sensorEvidence,
   });
 
   const pathNames = { ...declaration.path_names };
-  return resolveRuntimeSeamTreatment({
+  // 翻訳で広げた宣言は決着へ載せる。どの宣言の上で五条件を判定したかが残らないと、
+  // 「変換して通った」という記録が何についてのものか確定しない。
+  const resolved = await resolveRuntimeSeamTreatment({
     finding,
     witnessSet,
     pathNames,
@@ -176,6 +301,8 @@ export async function resolveRuntimeSeam({
     manifestDigest: baseArtifact.result_digest,
     affectedTests,
     taskMigrationDigest: declaration.task_migration_digest,
+    // storeへ記録されたfindingのidで縛る。再計画側はこのidでfinding recordを読む。
+    recordedFindingDigest: findingRecord.finding_digest,
     commitTransform: async ({ files, candidateId }) => commitSeamTransform({
       repoRoot, baseSha, files, candidateId,
     }),
@@ -205,6 +332,7 @@ export async function resolveRuntimeSeam({
       return { ...applied, candidate: applied.candidate ?? null };
     },
   });
+  return { ...resolved, widened: built.widened };
 }
 
 /** 決着をartifactにする。branchを動かすのは操作するAIなので、行き先を明示して返す。 */
@@ -215,6 +343,21 @@ export function buildRuntimeSeamResolution({ runId, findingDigest, resolved }) {
     finding_digest: findingDigest,
     lane: resolved.lane,
     reasons: [...resolved.reasons].sort(compareText),
+    // 確実の門（sc-012）。拒否理由を「宣言を直せば機械で通る」「AIが変換すべき」へ分類し、
+    // 次に誰が動くべきかを事実として返す。可否は決めない。
+    gate: explainSeamGate(resolved.reasons ?? []),
+    // 判定の前に宣言をどれだけ観測へ合わせたか。空配列は「予測が実態を覆っていた」という
+    // 意味であり、翻訳しなかったことと区別できる。
+    reconciled: [...(resolved.widened ?? [])]
+      .map((entry) => ({
+        todo_id: entry.todo_id,
+        resource: { kind: entry.resource.kind, target: entry.resource.target },
+        fields: [...entry.fields].sort(compareText),
+      }))
+      .sort((left, right) => compareText(
+        `${left.todo_id}\0${left.resource.kind}\0${left.resource.target}`,
+        `${right.todo_id}\0${right.resource.kind}\0${right.resource.target}`,
+      )),
     split: resolved.split ?? null,
     successor_base_sha: resolved.successor_base_sha ?? null,
     successor_base_ref: resolved.successor_base_ref ?? null,

package/src/runtime-seam-treatment.mjs

@@ -99,7 +99,7 @@ export async function resolveRuntimeSeamTreatment(options = {}) {
   const {
     finding, witnessSet, pathNames = {}, predeclaredTreatments = [],
     applyConflict, commitTransform, baseSha, manifestDigest, affectedTests = [],
-    taskMigrationDigest,
+    taskMigrationDigest, recordedFindingDigest = null,
   } = options;
 
   if (finding?.kind === 'observed_write_conflict' && typeof finding.path === 'string') {
@@ -112,6 +112,7 @@ export async function resolveRuntimeSeamTreatment(options = {}) {
 
   const { conflict, reasons } = seamConflictFromFinding({
     finding, witnessSet, pathNames, affectedTests, baseSha, manifestDigest,
+    recordedFindingDigest,
   });
   if (conflict === null) {
     return { lane: 'intentional_serial', treatment: null, split: null, reasons };