@quolu/lattice 0.32.0 → 0.33.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

@@ -1340,7 +1340,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 };

package/src/seam-apply.mjs

@@ -14,7 +14,7 @@ import { runIsolatedTransform } from './isolation-runner.mjs';
 import { collectSensorEvidence } from './sensor-adapter.mjs';
 import { invokeSensorCli } from './sensor-runtime.mjs';
 import { buildSeamDerivationQuerySet, deriveBoundedSeamCandidate } from './seam-derivation.mjs';
-import { planSeamRewrite } from './seam-rewrite.mjs';
+import { joinImportSurface, mentions, planSeamRewrite } from './seam-rewrite.mjs';
 import {
   buildPostTransformWitnessSet, compareExportSurface, evaluateSeamVerification, measureWaveCount,
 } from './seam-verification.mjs';
@@ -112,13 +112,38 @@ export async function readSymbolExtents({ cwd, sourcePath, symbols }) {
       const node = nodeOf(entry);
       if (node === null || node.name !== symbol || node.filePath !== sourcePath) continue;
       if (!Number.isSafeInteger(node.startLine) || !Number.isSafeInteger(node.endLine)) continue;
-      extents[symbol] = { startLine: node.startLine, endLine: node.endLine };
+      // 装飾込みの開始行（sensor v11）を優先する。Pythonの@decoratorやRustの#[derive]は
+      // 宣言の外の行にあり、宣言行だけで切ると装飾が残余面へ取り残される。
+      const start = Number.isSafeInteger(node.extentStartLine) && node.extentStartLine < node.startLine
+        ? node.extentStartLine : node.startLine;
+      // export状態もAST事実として持ち帰る（sc-013）。書き換え側のtext走査を置き換える。
+      extents[symbol] = { startLine: start, endLine: node.endLine, isExported: node.isExported === true };
     }
     if (extents[symbol] === undefined && entries.length >= SYMBOL_LOOKUP_LIMIT) truncated.push(symbol);
   }
   return { extents, truncated: [...new Set(truncated)].sort(compareText) };
 }
 
+/**
+ * 対象fileのimport面をsensorの観測から読む（sc-013）。
+ *
+ * `file-nodes`の`imports`（文の行範囲）と`import_bindings`（AST由来の束縛）を
+ * `joinImportSurface`で文単位へ束ねる。観測が取れなければnullを返し、書き換え側が
+ * `import_surface_missing`のtyped理由で止める——正規表現の再解析へfallbackしない。
+ */
+export function readImportSurface({ cwd, sourcePath }) {
+  const result = invokeSensorCli(
+    (command, args, options) => spawnSync(command, args, options),
+    ['file-nodes', sourcePath, '--path', '.'],
+    { cwd, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 },
+  );
+  if (result.status !== 0) return null;
+  let parsed;
+  try { parsed = JSON.parse(result.stdout); } catch { return null; }
+  if (!Array.isArray(parsed?.imports) || !Array.isArray(parsed?.import_bindings)) return null;
+  return joinImportSurface(parsed.imports, parsed.import_bindings);
+}
+
 async function runIn(worktreePath, command, args) {
   try {
     const { stdout } = await execFileAsync(command, args, {
@@ -130,6 +155,66 @@ async function runIn(worktreePath, command, args) {
   }
 }
 
+/**
+ * 変換で切断された参照を数える（検証網、ADR 0145）。
+ *
+ * 移した先のcodeが、残余面に留まったsymbol（module変数・非公開関数）へ束縛なしで言及して
+ * いれば、その参照は切断されている——moduleの読み込みは通り、実行して初めてReferenceErrorに
+ * なるので、focused testが当該経路を通らなければ黙って壊れたまま採用される。これを受入の
+ * 一点で数える。
+ *
+ * 残余面のsymbol一覧は、変換後worktreeのfresh indexから抽出精度で取る（`file-nodes`）。
+ * value-ref辺の名前フィルタはノード生成に効かないので、全小文字のmodule変数もここには載る。
+ * `unresolved_refs`は使わない——bare参照の切断はそこに記録されないことを実測で確認した
+ * （builtin呼び出しは載るが、未束縛のidentifier読みは載らない）。
+ *
+ * 検査は保守的である。`mentions`はtext一致なので、文字列やcomment内の同名語も
+ * 「切断の疑い」として数える——見逃す方向ではなく誤検出の方向へ倒す（fail closed）。
+ * 網は受入の一点だけで、過程には触れない。不認定は拒否ではなく、理由を見て直せば
+ * 何度でも再提出できる。
+ */
+async function detectSeveredReferences({ worktreePath, files, residualPath }) {
+  const readFileNodes = (target) => {
+    const result = invokeSensorCli(
+      (command, args, options) => spawnSync(command, args, options),
+      ['file-nodes', target, '--path', '.'],
+      { cwd: worktreePath, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 },
+    );
+    if (result.status !== 0) return null;
+    let parsed;
+    try { parsed = JSON.parse(result.stdout); } catch { return null; }
+    if (!Array.isArray(parsed?.nodes)) return null;
+    return parsed;
+  };
+
+  const residual = readFileNodes(residualPath);
+  if (residual === null) return { observed: false, entries: [] };
+  const residualNames = residual.nodes.map(({ name }) => name);
+
+  const entries = [];
+  for (const [target, body] of Object.entries(files)) {
+    if (target === residualPath) continue;
+    const own = readFileNodes(target);
+    if (own === null) return { observed: false, entries: [] };
+    const defined = new Set(own.nodes.map(({ name }) => name));
+    // import束縛はworktreeのfresh indexのAST観測から取る（sc-013）。text再解析をしない。
+    // 束縛が観測できないindexでは網の判定材料が欠けるので、unobservedへ倒す（fail closed）。
+    if (!Array.isArray(own.import_bindings)) return { observed: false, entries: [] };
+    const imported = new Set(own.import_bindings
+      .map(({ local }) => local).filter((name) => typeof name === 'string'));
+    for (const name of residualNames) {
+      if (defined.has(name) || imported.has(name)) continue;
+      if (mentions(body, name)) entries.push({ file: target, name });
+    }
+  }
+  return {
+    observed: true,
+    entries: entries.sort((left, right) => compareText(
+      `${left.file}\0${left.name}`, `${right.file}\0${right.name}`,
+    )),
+  };
+}
+
 /**
  * 変換後worktreeを再indexし、新pathが索引に載ったかを見る。
  *
@@ -230,6 +315,7 @@ export function seamConflictFromProposal({ proposal, witnessSet, pathNames = {}
  */
 export function seamConflictFromFinding({
   finding, witnessSet, pathNames = {}, affectedTests = [], baseSha, manifestDigest,
+  recordedFindingDigest = null,
 } = {}) {
   if (finding?.kind !== 'observed_write_conflict' || typeof finding.path !== 'string') {
     return { conflict: null, reasons: ['finding_not_write_conflict'] };
@@ -250,7 +336,11 @@ export function seamConflictFromFinding({
       baseSha,
       manifestDigest,
       // 実行時は提案artifactが無い。観測したfindingそのものを出所として縛る。
-      findingDigest: digestArtifact({
+      //
+      // **記録済みfindingのdigestがあるなら、それを使う。** 内容から再導出したdigestで縛ると、
+      // 「この変換はあのfindingへの答えだ」という記録が、storeに実在しないidを指す。実際、
+      // 再計画側は`findings/<digest>.json`を読むので、再導出値では必ず読めない。
+      findingDigest: recordedFindingDigest ?? digestArtifact({
         kind: finding.kind, path: finding.path, todo_ids: taskIds,
       }),
       candidateId: `seam-runtime-${sha16(`${finding.path}\0${taskIds.join(',')}`)}`,
@@ -314,6 +404,7 @@ export async function applySeamConflict({
   }
   const rewritten = planSeamRewrite({
     sourceText: beforeText, candidate, symbolExtents: lookup.extents,
+    importSurface: readImportSurface({ cwd: repoRoot, sourcePath }),
   });
   if (rewritten.files === null) {
     return { outcome: outcome({ planKey, decision: 'rejected', reasons: rewritten.reasons, candidate }), files: null };
@@ -361,9 +452,14 @@ export async function applySeamConflict({
         const owned = candidate.surfaces
           .filter(({ role }) => role === 'task_owned').map(({ path: target }) => target);
         const sensor = await observeFreshSensor({ worktreePath, latticeBin, paths: owned });
-        observation = { sensor, afterText: null, afterArtifact: null };
+        observation = { sensor, afterText: null, afterArtifact: null, severed: null };
         observation.afterText = await readFile(path.join(worktreePath, sourcePath), 'utf8');
         if (!sensor.fresh) return;
+        // 網は受入の一点だけ（ADR 0145）。fresh indexの上でしか意味を持たないので、
+        // sensorが新pathを見ていない時は数えず、observation欠落として別理由で落とす。
+        observation.severed = await detectSeveredReferences({
+          worktreePath, files: rewritten.files, residualPath: sourcePath,
+        });
         const post = buildPostTransformWitnessSet({
           witnessSet, candidate, affectedTestsByPath: sensor.affectedByPath,
         });
@@ -389,6 +485,7 @@ export async function applySeamConflict({
     exportSurface: observation?.afterText === null || observation?.afterText === undefined
       ? { preserved: false, missing: [] }
       : compareExportSurface({ before: beforeText, after: observation.afterText }),
+    severed: observation?.severed ?? null,
     focusedTestsPassed: verifierFailure === null,
     sensorFresh: observation?.sensor?.fresh === true,
     conflictPairs: afterPairs === null ? { targetResolved: false }