@quolu/lattice 0.32.0 → 0.34.0

package/src/runtime-io-sentinel.mjs

@@ -28,7 +28,7 @@ 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']);
+export const IO_WARNING_KINDS = Object.freeze(['io_overlap_warning', 'io_undeclared_write_warning']);
 
 /**
  * 監視から外すrepo相対prefix。
@@ -65,7 +65,7 @@ export function isExcludedPath(relativePath, excludes = DEFAULT_IO_EXCLUDES) {
  *
  * checkpoint findingの2述語をそのまま1 pathへ適用する:
  * - 他のrunning TODOの宣言scopeに入るpathへ書いた → `io_overlap_warning`
- * - 自分の宣言scopeの外へ書いた → `io_scope_warning`
+ * - 自分の宣言scopeの外へ書いた → `io_undeclared_write_warning`
  *
  * @returns {{warnings: Array<{kind: string, todo_ids: string[], path: string}>}}
  */
@@ -84,7 +84,7 @@ export function classifyIoObservation(options = {}) {
 
   const warnings = [];
   if (!coveredBy(packet.scope.writes, relativePath)) {
-    warnings.push({ kind: 'io_scope_warning', todo_ids: [todoId], path: relativePath });
+    warnings.push({ kind: 'io_undeclared_write_warning', todo_ids: [todoId], path: relativePath });
   }
   for (const otherId of [...runningTodoIds].sort(compareText)) {
     if (otherId === todoId) continue;
@@ -298,15 +298,22 @@ export function probeIoWarning({ warning, checkpointsByTodo } = {}) {
 }
 
 /**
- * 警報kind → finding kind。probeを通った警報だけがこの写像に乗る。
+ * 警報kind → finding kind。**重なりだけがhold経路へ乗る。**
  *
- * 述語が同一（`coveredBy`）なので、写像は1対1に決まる。ここで新しい種類を発明しない——
- * 発明すると、警報経由のfindingだけ既存の処置（請求項7の直列化、請求項8のseam変換）が
- * 効かない種類になってしまう。
+ * 宣言境界は計画時の**予測**であって、workerを閉じ込める制約ではない。範囲内へ無理に
+ * 押し込めるとworkerの自由度が落ち、成果の品質が下がる。だから自由に書かせ、**実際の足跡が
+ * 他の走行中TODOとぶつかった時にだけ**止めて処置する——請求項7（片方を停止し他方を確定して
+ * 再開する）と請求項8（限定的な変換を施して双方再開する）はそのための構成である。
+ *
+ * よって単独のscope警報——誰の領分とも重なっていない宣言外の書き込み——はhold経路へ運ばない。
+ * それは競合ではなく、**予測が実態より狭かったという情報**であり、止める理由が無い。記録は
+ * 残る（`io_warning_observed`）ので、再計画の材料としては失われない。
+ *
+ * 止めるべきでないものを止めると、処置の当てようが無い停止が生まれる。scope違反に処置が
+ * 無いのは欠落ではなく、処置すべき事象ではないことの現れである。
  */
 const WARNING_FINDING_KIND = Object.freeze({
   io_overlap_warning: 'observed_write_conflict',
-  io_scope_warning: 'scope_violation',
 });
 
 /**
@@ -320,7 +327,7 @@ 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;
+    if (warning.kind === 'io_undeclared_write_warning') return true;
     return warning.todo_ids.some((otherId) => {
       if (otherId === todoId) return false;
       const other = packets[otherId];

package/src/runtime-managed-supervisor.mjs

@@ -92,6 +92,28 @@ export async function observeMacosBinaryIdentity(binaryPath) {
   return identity;
 }
 
+/**
+ * 起動済みprocessが実際に実行しているimageのcanonical pathをOSから観測する。
+ * bytesの同一性はcallerがlaunch descriptorのSHA-256と照合する。
+ */
+export async function observeProcessExecutablePath(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 1) {
+    fail('ADAPTER_BINARY_IDENTITY_MISMATCH', 'exec後image PID不正');
+  }
+  if (process.platform === 'linux') {
+    return realpath(`/proc/${pid}/exe`);
+  }
+  if (process.platform === 'darwin') {
+    const { stdout } = await execFileAsync(
+      '/bin/ps',
+      ['-o', 'comm=', '-p', String(pid)],
+      { encoding: 'utf8' },
+    );
+    return realpath(stdout.trim());
+  }
+  fail('ADAPTER_BINARY_IDENTITY_MISMATCH', `exec後image path観測未対応platform: ${process.platform}`);
+}
+
 /** storeが解決したimmutable bindingからprocess/worktree/checkpointをDirect OSで再観測する。 */
 /**
  * 本repositoryの現在状態を1つのdigestへ畳む。
@@ -862,8 +884,7 @@ async function activateManagedSupervisorController({ repoRoot, runDir, runId, ad
       try { process.kill(child.pid, 0); } catch { fail('ADAPTER_CONTROLLER_UNAVAILABLE', 'controller process不達'); }
       let executedImage;
       try {
-        const { stdout } = await execFileAsync('/bin/ps', ['-o', 'comm=', '-p', String(child.pid)], { encoding: 'utf8' });
-        executedImage = await realpath(stdout.trim());
+        executedImage = await observeProcessExecutablePath(child.pid);
       } catch { fail('ADAPTER_BINARY_IDENTITY_MISMATCH', 'exec後image path観測失敗'); }
       if (executedImage !== binaryReal || sha256Bytes(await readFile(executedImage)) !== launch.binary_digest) {
         fail('ADAPTER_BINARY_IDENTITY_MISMATCH', 'exec後image path/bytes不一致');
@@ -1340,7 +1361,15 @@ if (isDirectDaemon) {
         commitPhaseRevision: (revision) => applyPhaseTodoRevision({
           repoRoot: path.resolve(runDir, '..', '..', '..'),
           writer: createTodoStoreWriter({ caller: 'g5-authoring' }), revision,
-          actor: 'lattice-runtime-supervisor', recordedAt: new Date().toISOString(),
+          // actorは`{host, session, agent}`のexact recordである（`lattice.todo_event.v4`）。
+          // 文字列を渡していた間、seam_splitの再計画はphase revisionをcommitできなかった
+          // ——工程storeへ書く直前で必ず落ちるので、請求項8の再開まで一度も届いていない。
+          actor: {
+            host: 'lattice-runtime',
+            session: sessionNonce.slice(0, 32),
+            agent: 'lattice-runtime-supervisor',
+          },
+          recordedAt: new Date().toISOString(),
         }),
       });
     })

package/src/runtime-multi-epoch-store.mjs

@@ -83,7 +83,7 @@ export function validateRuntimeFindingRecord(value) {
     || new Set(finding.evidence_digests).size !== finding.evidence_digests.length
     || finding.evidence_digests.some((entry, index) => index > 0 && finding.evidence_digests[index - 1] >= entry)
     || !selfDigestValid(finding, 'finding_digest')) return false;
-  const pathKind = ['observed_write_conflict', 'scope_violation', 'stale_context'].includes(finding.kind);
+  const pathKind = ['observed_write_conflict', 'undeclared_write', 'stale_context'].includes(finding.kind);
   if (pathKind !== (finding.path !== null) || pathKind === (finding.resource_id !== null)) return false;
   const observer = value.recorded_by;
   return exactRecord(observer, ['schema', 'kind', 'controller_registration_digest',
@@ -109,7 +109,7 @@ export function validateRuntimeFindingCandidate(value) {
     || value.evidence_digests.some((digest, index) => index > 0
       && value.evidence_digests[index - 1] >= digest)
     || !selfDigestValid(value, 'candidate_digest')) return false;
-  const pathKind = ['observed_write_conflict', 'scope_violation', 'stale_context']
+  const pathKind = ['observed_write_conflict', 'undeclared_write', 'stale_context']
     .includes(value.proposed_kind);
   return pathKind
     ? typeof value.path === 'string' && value.path.length > 0 && value.resource_id === null

package/src/runtime-projection.mjs

@@ -238,5 +238,32 @@ export function projectRuntimeStatusOverlays(options = {}) {
     carry_over: members('carry_over'),
     redispatch: members('redispatch'),
     intake_frozen: runtimeState.freeze !== null,
+    treatment_advice: treatmentAdvice(events),
+  };
+}
+
+/**
+ * 止まっているrunに対して、請求項8（変換）を試せるかを助言する。
+ *
+ * 拒否ではなく助言である（ADR 0128と同じ規律）。既定の再計画modeが`intentional_serial`だから
+ * といって「変換が不可能」ではない——事前宣言が無いだけである。実行時に初めて見つかった競合には
+ * 事前宣言が無いので、既定だけを見ると請求項8へ行く道が無いように見える。
+ *
+ * 装置が言えるのは**係争資源が切れる種類か**までとする。共有stateや外部effectは面を分けても
+ * 同じ資源に触り続けるので切れない。pathは分けられる**かもしれない**——実際に切れるかと、
+ * それが割に合うかは、隔離worktreeで変換して五条件で測って初めて分かる（`run seam resolve`）。
+ * 試すかどうかは費用のかかる判断なので、装置は決めずに材料だけ渡す。
+ */
+function treatmentAdvice(events) {
+  const conflict = [...events].reverse()
+    .find((event) => event.kind === 'conflict_found'
+      && event.payload !== null && typeof event.payload === 'object');
+  if (conflict === undefined) return null;
+  const severability = typeof conflict.payload.path === 'string' ? 'code_seam' : 'serial';
+  return {
+    finding_digest: typeof conflict.payload.finding_digest === 'string'
+      ? conflict.payload.finding_digest : null,
+    severability,
+    transform_attemptable: severability === 'code_seam',
   };
 }

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

@@ -511,6 +511,21 @@ export async function createScriptedAdapterController({
   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,
@@ -904,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,
@@ -947,6 +964,7 @@ export async function createScriptedAdapterController({
     controllerSessionNonce,
     descriptor: structuredClone(descriptor),
     heartbeat,
+    reapWorkers,
     leaseSetDigest() {
       return digestArtifact([...stagedLeases.keys(), ...armedLeases.keys()].sort());
     },
@@ -1102,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 };