@quolu/lattice 0.32.0 → 0.34.0

package/src/runtime-cli.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { constants as fsConstants } from 'node:fs';
 import {
   lstat,
@@ -139,6 +139,20 @@ const KNOWN_ADAPTERS = Object.freeze(['scripted', 'isolated-worktree', 'actual-a
  * 超えたら`rejected`として理由ごとjournalへ残す（黙って見送らない）。
  */
 const IO_ESCALATION_LOCK_TIMEOUT_MS = 15_000;
+/**
+ * 係争pathから資源idを導出する（front-endと同じ形）。
+ *
+ * front-endは`owns`から`own-<kind>-<sha256(target)先頭16>`を作る。path競合の直列化資源は
+ * その形でなければ、後継planの競合辺が実ownershipの資源と別物になってしまう。
+ * **形を1箇所で決める。** 別の形で作ると、同じpathが別の資源に見える。
+ */
+function ownedResourceId(kind, target) {
+  return `own-${kind}-${createHash('sha256').update(target, 'utf8').digest('hex').slice(0, 16)}`;
+}
+
+function ownedPathResourceId(pathValue) {
+  return ownedResourceId('path', pathValue);
+}
 /** 走行中workerの完了を待つ上限と間隔。待てないと走行中の観測が成立しない。 */
 const SCRIPTED_OBSERVE_TIMEOUT_MS = 120_000;
 const SCRIPTED_OBSERVE_POLL_MS = 20;
@@ -743,6 +757,80 @@ async function readScriptedControllerReceipt({
   return receipt;
 }
 
+/**
+ * hold裁定をworker processへ反映する（請求項7・8の再開側）。
+ *
+ * **barrierは全workerを止める。** 静止の証明はrun全体に対して要るからである。hold裁定は
+ * 止めた相手を`hold_set`と`continue_set`へ分け、後者は「影響閉包の外なので作業を捨てない」
+ * と判定されたものである。
+ *
+ * **carry-overは「一度も止まらない」ではない。** rebindは静止を要求する
+ * （`write_enabled === false`）ので、holdの直後に再開すると後継epochへ束ね直せず
+ * `EPOCH_REBIND_INCOMPLETE`で落ちる。止まり、繋がれ、そこで動き出すのが正しい順序である。
+ * よってこの関数を呼ぶのはrebindが済んだ後だけとする。
+ *
+ * pidだけで再開しない。pidは再利用されるので、start identityを照合して記録と同じprocessで
+ * あることを確かめる——別のprocessをSIGCONTするのは、止めるのと同じくらい危険である。
+ */
+async function resumeContinuedWorkers({ events, todoIds }) {
+  if (!Array.isArray(todoIds) || todoIds.length === 0) return { resumed: [], skipped: [] };
+  const resumed = [];
+  const skipped = [];
+  for (const todoId of todoIds) {
+    const dispatch = events.findLast((event) => event.kind === 'executor_dispatched'
+      && event.subject?.kind === 'todo' && event.subject.ref === todoId);
+    const binding = dispatch?.payload?.direct_os_observation_binding;
+    const pid = binding?.process_pid;
+    const recorded = binding?.process_start_identity?.identity_digest;
+    if (!Number.isSafeInteger(pid) || typeof recorded !== 'string') continue;
+    // pidは再利用される。記録と同じprocessであることを確かめてから再開する——
+    // 別のprocessをSIGCONTするのは、止めるのと同じくらい危険である。
+    const observed = await observeManagedProcessStartIdentity(pid).catch(() => null);
+    if (observed === null || observed.identity_digest !== recorded) {
+      skipped.push({ todo_id: todoId, reason: observed === null ? 'process不在' : 'start identity不一致' });
+      continue;
+    }
+    try { process.kill(pid, 'SIGCONT'); resumed.push(todoId); } catch {
+      skipped.push({ todo_id: todoId, reason: 'SIGCONT失敗' });
+    }
+  }
+  return { resumed, skipped };
+}
+
+/**
+ * runが起こしたworker processを、耐久記録から回収する。
+ *
+ * **記録が正本である。** 誰を起こしたかは`executor_dispatched`の
+ * `direct_os_observation_binding`が持っており、controllerが落ちていても残る。
+ *
+ * pidだけで殺さない。pidは再利用されるので、start identityを取り直して記録と一致した
+ * ものだけを止める——一致しなければ、それは別のprocessである。
+ *
+ * SIGKILLで送る。holdで止めたworkerはSIGSTOP状態にあり、SIGTERMは継続されるまで
+ * 配送されない。停止したまま放置されたprocessは自分では終われない。
+ */
+async function reapRunWorkerProcesses({ events }) {
+  const reaped = [];
+  const skipped = [];
+  const seen = new Set();
+  for (const event of events) {
+    if (event.kind !== 'executor_dispatched') continue;
+    const binding = event.payload?.direct_os_observation_binding;
+    const pid = binding?.process_pid;
+    const recorded = binding?.process_start_identity?.identity_digest;
+    if (!Number.isSafeInteger(pid) || typeof recorded !== 'string' || seen.has(pid)) continue;
+    seen.add(pid);
+    const observed = await observeManagedProcessStartIdentity(pid).catch(() => null);
+    if (observed === null) continue; // 既に居ない
+    if (observed.identity_digest !== recorded) {
+      skipped.push({ pid, reason: 'start identity不一致（pid再利用）' });
+      continue;
+    }
+    try { process.kill(pid, 'SIGKILL'); reaped.push(pid); } catch { /* 競合で既に消えた */ }
+  }
+  return { reaped, skipped };
+}
+
 async function driveInitialScriptedManagedEpoch({
   runDir,
   repoRoot,
@@ -1130,6 +1218,64 @@ async function runSeamResolve({ runDir, repoRoot, findingDigest, requestPath, st
   return resolution.lane === 'seam_transform' ? 0 : 1;
 }
 
+/**
+ * 切断コストの内訳を、記録済みfindingについて投影する（read-only、docs/plan_seam-cost.md）。
+ *
+ * `seam resolve`が隔離worktreeで実変換まで行うのに対し、これは**変換を試す前の安い観測**である。
+ * 「何を共有しているから単純に切れないのか」を数えられる事実として返し、試すかどうかの判断は
+ * 操作するAIに残す。閾値も可否判定も返さない。投影であって記録ではないので、runへ何も書かない。
+ *
+ * symbolの帰属（concern_symbols）は入力で受ける。実行時のwitnessはpath単位の宣言しか持たず、
+ * 係争fileの中で誰がどのsymbolを触るかはAIだけが知っている——ここで推定しない。
+ */
+async function runSeamProfile({ runDir, repoRoot, findingDigest, inputPath, stdout }) {
+  const committed = await readCommittedEpochStore(runDir);
+  if (committed === null) {
+    throw new CliContractError('RUN_NOT_MANAGED', 'runがmanaged storeへactivateされていない');
+  }
+  const found = await readRuntimeFindingRecord({
+    runDir, findingDigest, planEpoch: committed.pointer.plan_epoch,
+  });
+  if (found.record === null) throw new CliContractError('STALE_FINDING', found.reason);
+  const finding = found.record.finding;
+  if (typeof finding.path !== 'string') {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE',
+      'path findingではない競合に切断コストの内訳は立たない');
+  }
+
+  const declaration = await readBoundedJson(inputPath, 'seam profile input');
+  const identifier = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/u;
+  const symbols = declaration?.concern_symbols;
+  const todoIds = [...finding.todo_ids].sort();
+  const declaredIds = symbols === null || typeof symbols !== 'object' || Array.isArray(symbols)
+    ? null : Object.keys(symbols).sort();
+  if (declaredIds === null
+    || declaredIds.join('\0') !== todoIds.join('\0')
+    || declaredIds.some((todoId) => !Array.isArray(symbols[todoId])
+      || symbols[todoId].length === 0
+      || !symbols[todoId].every((name) => identifier.test(name)))) {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE',
+      'concern_symbolsがfindingのtodo集合と一致しない。'
+      + `{"concern_symbols": {${todoIds.map((id) => `"${id}": ["<symbol>"]`).join(', ')}}}の形で渡す`);
+  }
+
+  let sourceText;
+  try {
+    sourceText = await readFile(path.join(repoRoot, finding.path), 'utf8');
+  } catch {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE', `係争fileを読めない: ${finding.path}`);
+  }
+  const { computeSeamCostProfile } = await import('./seam-cost.mjs');
+  const { profile, reasons } = await computeSeamCostProfile({
+    repoRoot, sourcePath: finding.path, sourceText, ownedSymbolsByTask: symbols,
+  });
+  if (profile === null) {
+    throw new CliContractError('SEAM_PROFILE_UNAVAILABLE', reasons.join(',') || 'profile_unavailable');
+  }
+  stdout.write(`${JSON.stringify(profile)}\n`);
+  return 0;
+}
+
 async function runObserve({ runDir, stdout }) {
   const { events } = await readRunStore(runDir);
   const chain = verifyRunEventChain({ events });
@@ -1179,7 +1325,9 @@ async function runStatus({ runDir, stdout }) {
   if (managed !== null) {
     output.schema = 'lattice.managed_run_status.v1';
     const runtimeProjection = {
-      schema: 'lattice.runtime_status_projection.v1',
+      // v2は`treatment_advice`の追加。既定modeが直列化でも変換を試せる場合があることを、
+      // 運転側が見える形にした（ct-003）。
+      schema: 'lattice.runtime_status_projection.v2',
       ...projectRuntimeStatusOverlays({ events }),
       runtime_frozen: managedFrozen,
     };
@@ -1844,8 +1992,6 @@ export async function runManagedSupervisorDaemon({
    * 自分のprocessで作業するので、そのprocessを止めると制御そのものが止まる——止めない限り
    * 証明できず、止めれば応答できない。**別processのexecutorを持つまでこの穴は埋まらない。**
    */
-  const canProveQuiescence = () => true;
-
   const attributionIsDistinct = (warning, roots) => {
     const paths = warning.todo_ids.map((todoId) => roots[todoId]);
     if (paths.some((value) => typeof value !== 'string')) return false;
@@ -1974,19 +2120,6 @@ export async function runManagedSupervisorDaemon({
       return decide('skipped',
         'worktree rootを共有する構成では書き手を特定できない（帰属はrootだけで決まる）');
     }
-    // **holdは静止の証明を要求する。** 直接OS観測はexecutorのprocessが実際に停止している
-    // ことまで確かめるが、executorがcontroller自身のprocessである構成では、止めると
-    // 制御そのものが止まるので証明できない。
-    //
-    // ここで止めるのは、conflictがintakeをfreezeするからである。freezeしてholdが通らない
-    // 状態を作ると、runは進むことも畳むこともできなくなる（abandonも静止を要求する）。
-    // 止められないと分かっているなら、freezeさせない方が安全側である。判定はcheckpointが
-    // 従来どおり担う——早期警報は早めるためだけに在るという原則どおり。
-    if (!canProveQuiescence()) {
-      return decide('rejected',
-        'executorがcontroller自身のprocessで走っており、静止を証明できない'
-        + '（停止すると制御も止まる）。freezeさせるとrunを畳めなくなるので進めない');
-    }
     const recorded = await recordCheckpoints(escalation, probed.checkpoints);
     if (!recorded.ok) return decide(recorded.outcome, recorded.detail);
 
@@ -2097,14 +2230,18 @@ export async function runManagedSupervisorDaemon({
   /** 警報の処理を直列化する鎖。`onWarning`はここへ繋ぐだけにする。 */
   let escalationChain = Promise.resolve();
 
-  const resolveObservationBinding = async ({ binding }) => {
+  const resolveObservationBinding = async ({ binding, ack }) => {
+    // rebind経路はrunning bindingを持たず、ackだけで来る（`kind: 'rebind'`）。どちらから来ても
+    // 同じdispatch記録へ辿り着けなければ、繋ぎ直す相手を特定できない。
+    const todoId = binding?.todo_id ?? ack?.todo_id;
+    const executorHandle = binding?.executor_handle ?? ack?.executor_handle;
     const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
     const dispatch = events.findLast((event) => event.kind === 'executor_dispatched'
-      && event.subject?.kind === 'todo' && event.subject.ref === binding?.todo_id
-      && event.payload?.executor_handle === binding?.executor_handle);
+      && event.subject?.kind === 'todo' && event.subject.ref === todoId
+      && event.payload?.executor_handle === executorHandle);
     const observation = dispatch?.payload?.direct_os_observation_binding;
     if (observation === null || typeof observation !== 'object' || Array.isArray(observation)) {
-      throw new ManagedRuntimeError('HOLD_ACKS_INCOMPLETE', `durable Direct OS binding不足: ${binding?.todo_id ?? 'unknown'}`);
+      throw new ManagedRuntimeError('HOLD_ACKS_INCOMPLETE', `durable Direct OS binding不足: ${todoId ?? 'unknown'}`);
     }
     return structuredClone(observation);
   };
@@ -2429,6 +2566,19 @@ export async function runManagedSupervisorDaemon({
         if (finding.plan_epoch !== active.pointer.plan_epoch) {
           throw new ManagedRuntimeError('STALE_FINDING', 'findingはactive epochに属さない');
         }
+        // 競合は2者以上いて初めて競合である。1者しか名指していない観測——誰の領分とも
+        // 重なっていない予測超過——でfreezeすると、抜け道が無い。処置は2つとも2者を要求する
+        // （直列化は`todo_ids.length >= 2`、seam変換は2つの面へ切る）ので、legalなrecompileが
+        // 作れないまま止まる。予測が狭かっただけなので、記録して次のcompileで宣言を実態へ
+        // 合わせるのが正しい応答である。
+        if ((finding.finding?.todo_ids ?? []).length < 2) {
+          throw new ManagedRuntimeError('FINDING_NOT_A_CONFLICT',
+            '1 TODOしか名指していない観測はfreezeへ運べない。'
+            + '予測超過は競合ではないので、記録のまま次のcompileで宣言を観測へ合わせる', {
+              finding_kind: finding.finding?.kind ?? null,
+              todo_ids: [...(finding.finding?.todo_ids ?? [])],
+            });
+        }
         let events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
         const todoId = finding.finding?.todo_ids?.[0] ?? active.bundle.plan.nodes[0].todo_id;
         events.push(buildNextRunEvent({ events, runId: request.request_id, kind: 'conflict_found', planEpoch: active.pointer.plan_epoch,
@@ -2647,20 +2797,40 @@ export async function runManagedSupervisorDaemon({
             !== canonicalizeArtifact(treatment.todo_ids ?? treatment.predecessor_task_ids)) {
           throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'treatmentがhold finding/todo集合と一致しない');
         }
-        if (recompileRequest.mode === 'intentional_serial'
-          && treatmentFinding.finding.resource_id !== treatment.resource_id) {
-          throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceがfinding resourceと一致しない');
-        }
-        if (recompileRequest.mode === 'intentional_serial'
-          && !treatment.todo_ids.every((todoId) => {
-            const manifest = active.bundle.manifests[todoId];
-            return manifest?.resources?.includes(treatment.resource_id)
-              || manifest?.state_effects?.some((effect) => effect.resource_id === treatment.resource_id);
-          })) {
-          throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceをfresh ownershipから再導出できない');
+        if (recompileRequest.mode === 'intentional_serial') {
+          // **path競合には資源idが無い。** finding契約はpath形の`resource_id`をnullと定めており、
+          // path由来の資源idはmanifestの`resources`にも載らない（載るのは宣言したbare資源だけ）。
+          // それでもrouteConflictTreatmentはpath競合を直列化レーンへ振る——請求項7の
+          // 「一方を停止し、他方を確定し、停止した方を再開する」がその経路だからである。
+          //
+          // よってpath findingの時は、係争pathからfront-endと同じ形で資源idを導出して照合する。
+          // 導出値との一致を要求するので、資源idを捏造できないという元の保証は保たれる
+          // ——照合先がfindingそのものへ固定されるため、manifest所属を見る必要が無い。
+          const expectedResource = treatmentFinding.finding.path === null
+            ? treatmentFinding.finding.resource_id
+            : ownedPathResourceId(treatmentFinding.finding.path);
+          if (expectedResource !== treatment.resource_id) {
+            throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceがfinding resourceと一致しない');
+          }
+          // 宣言済み資源の競合は、従来どおり実ownershipから再導出できることまで要求する。
+          if (treatmentFinding.finding.path === null
+            && !treatment.todo_ids.every((todoId) => {
+              const manifest = active.bundle.manifests[todoId];
+              return manifest?.resources?.includes(treatment.resource_id)
+                || manifest?.state_effects?.some((effect) => effect.resource_id === treatment.resource_id);
+            })) {
+            throw new ManagedRuntimeError('INVALID_RECOMPILE_REQUEST', 'serial resourceをfresh ownershipから再導出できない');
+          }
         }
         if (recompileRequest.mode === 'seam_split') {
+          // **宣言された面の所有も数える。** `resources`／`state_effects`だけを見ていた間、
+          // path所有はbefore/afterのどちらにも現れず、seam splitが述べる`added`は常に空の
+          // 導出値と突き合わされていた——path競合を切るsplitは原理的に一致しなかった。
+          // 資源idの合成形は`verifySeamSplitSuccessor`と同じ`own-<kind>-<sha16>`にする。
           const ownership = (manifests) => Object.entries(manifests).flatMap(([todoId, manifest]) => [
+            ...(manifest.owns ?? []).map((own) => ({
+              resource_id: ownedResourceId(own.kind, own.target),
+              owner_todo_id: todoId, access_kind: 'own' })),
             ...manifest.resources.map((resourceId) => ({ resource_id: resourceId,
               owner_todo_id: todoId, access_kind: 'own' })),
             ...manifest.state_effects.map((effect) => ({ resource_id: effect.resource_id,
@@ -2674,9 +2844,41 @@ export async function runManagedSupervisorDaemon({
           ].sort((left, right) => canonicalizeArtifact(left).localeCompare(canonicalizeArtifact(right)));
           const difference = (left, right) => left.filter((entry) => !right.some((other) =>
             canonicalizeArtifact(entry) === canonicalizeArtifact(other)));
-          const beforeOwnership = ownership(active.bundle.manifests);
+          // **比較の起点は、観測へ合わせた後の宣言である。**
+          //
+          // 実行時に見つかった競合は、片方がその資源を所有していないから起きる。変換はその
+          // 宣言を観測へ合わせてから導出されるので（翻訳段）、splitが述べる遷移も合わせた後の
+          // 状態からのものになる。ここで記録のままのpredecessorと比べると、実行時に見つかった
+          // 競合から作ったsplitは永久に一致しない——請求項8が実行時に届かなくなる。
+          //
+          // 合わせる材料はfindingそのものであり、宣言でも入力でもない。再導出なので、
+          // 呼び出し側が何を主張しても結果は変わらない。
+          const contestedResource = treatmentFinding.finding.path === null
+            ? treatmentFinding.finding.resource_id
+            : ownedPathResourceId(treatmentFinding.finding.path);
+          const observedTodoIds = [...treatmentFinding.finding.todo_ids].sort();
+          const reconciledOwnership = [...ownership(active.bundle.manifests)];
+          for (const todoId of observedTodoIds) {
+            const entry = { resource_id: contestedResource, owner_todo_id: todoId, access_kind: 'own' };
+            if (!reconciledOwnership.some((other) => canonicalizeArtifact(other) === canonicalizeArtifact(entry))) {
+              reconciledOwnership.push(entry);
+            }
+          }
+          const reconciledEdges = [...edges(active.bundle.plan)];
+          for (let left = 0; left < observedTodoIds.length; left += 1) {
+            for (let right = left + 1; right < observedTodoIds.length; right += 1) {
+              const edge = { from_todo_id: observedTodoIds[left], to_todo_id: observedTodoIds[right],
+                kind: 'conflict' };
+              if (!reconciledEdges.some((other) => canonicalizeArtifact(other) === canonicalizeArtifact(edge))) {
+                reconciledEdges.push(edge);
+              }
+            }
+          }
+          const sortEntries = (entries) => [...entries]
+            .sort((left, right) => canonicalizeArtifact(left).localeCompare(canonicalizeArtifact(right)));
+          const beforeOwnership = sortEntries(reconciledOwnership);
           const afterOwnership = ownership(compiled.manifests);
-          const beforeEdges = edges(active.bundle.plan);
+          const beforeEdges = sortEntries(reconciledEdges);
           const afterEdges = edges(newPlan);
           const derivedOwnership = { added: difference(afterOwnership, beforeOwnership),
             removed: difference(beforeOwnership, afterOwnership) };
@@ -2825,6 +3027,20 @@ export async function runManagedSupervisorDaemon({
           rebindEvidence.set(todoId, { ...evidence,
             controller_registration_digest: owner.registration.registration_digest });
         }
+        // **ここが再開の位置である。** rebindは静止を要求する（`write_enabled === false`）ので、
+        // holdの直後に再開すると後継epochへ束ね直せない。carry-overは「作業を捨てない」で
+        // あって「一度も止まらない」ではない——barrierで止まり、rebindで新epochへ繋がれ、
+        // そこで初めて動き出す。
+        if (rebound.size > 0) {
+          const resumed = await resumeContinuedWorkers({ events, todoIds: [...rebound] });
+          if (resumed.resumed.length > 0 || resumed.skipped.length > 0) {
+            await appendControl({ run_id: request.request_id, kind: 'workers_resumed',
+              session_nonce_digest: digestArtifact(sessionNonce), payload: {
+                resumed_todo_ids: [...resumed.resumed].sort(),
+                skipped_count: resumed.skipped.length,
+              } });
+          }
+        }
         for (const todoId of core.planDiff.redispatched) {
           const successors = recompileRequest.task_migration.entries
             .find((entry) => entry.predecessor_task_id === todoId)?.successor_task_ids ?? [];
@@ -3002,9 +3218,22 @@ export async function runManagedSupervisorDaemon({
             recordedAt: canonicalNow() })];
         }
         await replaceEventsAtomically(runDir, events);
-        // abandonは成果を捨てる決定なので、workerの木も畳む。closeでは畳まない——
-        // 木そのものがrunの成果であり、着地させる前に消したら受理した内容が残らない。
+        // **abandonは成果を捨てる決定である。** worker processの終了はcleanupではなく
+        // その決定の一部なので、誰を止めたかを記録へ残す。closeでは何もしない——
+        // 完走したrunのworkerは既にterminalであり、生きていればそれは欠陥である
+        // （`closeRunIfComplete`が全TODO accepted を要求するので、そもそもcloseへ来ない）。
         if (controlRequest.operation === 'abandon') {
+          const reaped = await reapRunWorkerProcesses({ events }).catch(() => null);
+          if (reaped !== null && (reaped.reaped.length > 0 || reaped.skipped.length > 0)) {
+            await appendControl({ run_id: request.request_id, kind: 'worker_processes_terminated',
+              session_nonce_digest: digestArtifact(sessionNonce), payload: {
+                reason: shutdownReason,
+                terminated_pids: [...reaped.reaped].sort((left, right) => left - right),
+                skipped_count: reaped.skipped.length,
+              } });
+          }
+          // 木も畳む。closeでは畳まない——木そのものがrunの成果であり、着地させる前に
+          // 消したら受理した内容が残らない。
           await removeScriptedWorktrees({ repoRoot, runDir }).catch(() => null);
         }
         await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
@@ -3528,6 +3757,11 @@ export async function runManagedSupervisorDaemon({
     // 監視fdを残さない。取り残すとtest fixtureの後片付けが重くなる。
     sentinel?.close();
     sentinel = null;
+    // **これは事故処理であって、正しい閉じ方ではない。** 正規の終了はabandon（破棄の決定）か
+    // hold後の再開であり、そのどちらも通らずdaemonが落ちる時だけここへ来る。停止した
+    // workerは自分では終われないので、記録から辿って道連れにする。
+    await readBoundedJson(path.join(runDir, 'events.json'), 'run events')
+      .then((events) => reapRunWorkerProcesses({ events })).catch(() => null);
     if (activationCommitted && activation !== null) {
       await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
         session_nonce_digest: digestArtifact(sessionNonce), payload: { signal } });
@@ -3693,6 +3927,16 @@ export async function runRuntimeCli({ argv, cwd, stdout, stderr }) {
         requestId: requestIdOverride,
       });
     };
+  } else if (argv.length === 9
+    && argv[0] === 'run' && argv[1] === 'seam' && argv[2] === 'profile'
+    && argv[3] === '--run' && typeof argv[4] === 'string' && argv[4].length > 0
+    && argv[5] === '--finding' && /^[0-9a-f]{64}$/u.test(argv[6])
+    && argv[7] === '--input' && typeof argv[8] === 'string' && argv[8].length > 0) {
+    action = async () => {
+      const { repoRoot, runDir } = await resolveRunStore(cwd, argv[4]);
+      return runSeamProfile({ runDir, repoRoot, findingDigest: argv[6],
+        inputPath: path.resolve(cwd, argv[8]), stdout });
+    };
   } else if (argv.length === 9
     && argv[0] === 'run' && argv[1] === 'seam' && argv[2] === 'resolve'
     && argv[3] === '--run' && typeof argv[4] === 'string' && argv[4].length > 0

package/src/runtime-contracts.mjs

@@ -53,7 +53,7 @@ export const RUNTIME_CONFLICT_KINDS = Object.freeze([
   'observed_write_conflict',
   'semantic_conflict_unknown',
   'effect_conflict_unknown',
-  'scope_violation',
+  'undeclared_write',
   'stale_context',
 ]);
 export const HOLD_REASON_KINDS = Object.freeze([

package/src/runtime-control-store.mjs

@@ -161,7 +161,7 @@ export function validateRuntimeControlEventPayload(kind, value) {
   // 機械が何かに気づいたのに黙っている状態を残さない。
   if (kind === 'io_warning_observed') {
     return exact(value, ['warning_kind', 'todo_ids', 'path', 'probe_outcome', 'warning_digest'])
-      && ['io_overlap_warning', 'io_scope_warning'].includes(value.warning_kind)
+      && ['io_overlap_warning', 'io_undeclared_write_warning'].includes(value.warning_kind)
       && Array.isArray(value.todo_ids) && value.todo_ids.length >= 1 && value.todo_ids.length <= 256
       && value.todo_ids.every(identifier)
       && value.todo_ids.every((id, index) => index === 0 || value.todo_ids[index - 1] < id)
@@ -171,6 +171,29 @@ export function validateRuntimeControlEventPayload(kind, value) {
         warning_kind: value.warning_kind, todo_ids: value.todo_ids, path: value.path,
       });
   }
+  // hold裁定のcontinue_setをprocessへ反映した記録（請求項7・8の再開側）。
+  // barrierは全workerを止めるので、続けてよいと判定した作業を再開しなければ、
+  // 判定と実行が食い違ったままになる。
+  if (kind === 'workers_resumed') {
+    return exact(value, ['resumed_todo_ids', 'skipped_count'])
+      && Array.isArray(value.resumed_todo_ids) && value.resumed_todo_ids.length <= 4096
+      && value.resumed_todo_ids.every(identifier)
+      && value.resumed_todo_ids.every((id, index) => index === 0
+        || value.resumed_todo_ids[index - 1] < id)
+      && Number.isSafeInteger(value.skipped_count) && value.skipped_count >= 0;
+  }
+  // 破棄の決定としてworker processを終了した記録。**cleanupではない。**
+  // 停止したworkerの行き先は「再開」か「破棄」の二択であり、破棄を選んだなら
+  // 誰を止めたかが残っていなければ、後から何が捨てられたか説明できない。
+  if (kind === 'worker_processes_terminated') {
+    return exact(value, ['reason', 'terminated_pids', 'skipped_count'])
+      && typeof value.reason === 'string' && value.reason.length > 0
+      && Array.isArray(value.terminated_pids) && value.terminated_pids.length <= 4096
+      && value.terminated_pids.every((pid) => Number.isSafeInteger(pid) && pid > 0)
+      && value.terminated_pids.every((pid, index) => index === 0
+        || value.terminated_pids[index - 1] < pid)
+      && Number.isSafeInteger(value.skipped_count) && value.skipped_count >= 0;
+  }
   // probeを通った警報を既存hold経路へ入れた顛末（ADR 0143の三段目）。
   // 成否どちらも残す。自動escalationが黙って失敗する状態を作らない——失敗の理由は
   // `detail`が持ち、これが無いと「警報は出たのにholdが掛かっていない」を後から説明できない。

package/src/runtime-decision-verifier.mjs

@@ -150,7 +150,7 @@ export function classifyObservedDiff(options = {}) {
     const declaredWrites = manifests[todoId].writes ?? [];
     for (const path of paths) {
       if (!declaredWriteCovers(declaredWrites, path)) {
-        findings.push({ kind: 'scope_violation', todo_ids: [todoId], path });
+        findings.push({ kind: 'undeclared_write', todo_ids: [todoId], path });
       }
     }
   }

package/src/runtime-diff-observer.mjs

@@ -257,7 +257,7 @@ export function coveredBy(declaredWrites, observedPath) {
  * cross-bindし、closed conflict分類のfindingを返す（producer側の検出。独立再計算は
  * runtime-decision-verifierの`classifyObservedDiff`が行う）。
  *
- * - scope_violation: 宣言write scope外へのwrite（offender=当該TODO）。
+ * - undeclared_write: 宣言write scope外へのwrite（offender=当該TODO）。
  * - observed_write_conflict: 他のrunning TODOのdeclared writeとのpath overlap。
  */
 export function detectCheckpointFindings(options = {}) {
@@ -276,7 +276,7 @@ export function detectCheckpointFindings(options = {}) {
   const findings = [];
   for (const entry of [...checkpoint.diff.entries].sort((l, r) => (l.path < r.path ? -1 : 1))) {
     if (!coveredBy(packet.scope.writes, entry.path)) {
-      findings.push({ kind: 'scope_violation', todo_ids: [todoId], path: entry.path });
+      findings.push({ kind: 'undeclared_write', todo_ids: [todoId], path: entry.path });
     }
   }
   for (const otherId of [...runningTodoIds].sort()) {

package/src/runtime-front-end.mjs

@@ -247,6 +247,25 @@ function affectedPayload(raw, expectPath) {
   return plainRecord(payload) ? payload : null;
 }
 
+/**
+ * 収集済みsensor evidenceから、あるpathのaffected testを読む。
+ *
+ * 実行時の翻訳段（宣言を観測へ合わせる）が同じ観測を必要とする。payloadの形の解釈をあちらへ
+ * 書き直すと、driftを判定する規則と、driftを起こさない宣言を作る規則が別々に育つ。
+ *
+ * @returns {string[]|null} 観測できなければnull（空配列と区別する）
+ */
+export function affectedTestsFromEvidence({ sensorEvidence, querySet, path: target } = {}) {
+  const queries = (querySet?.queries ?? [])
+    .filter((query) => query.operation === 'affected' && query.target === target);
+  if (queries.length !== 1) return null;
+  const outcome = (sensorEvidence?.outcomes ?? [])
+    .find((entry) => entry.query_id === queries[0].id);
+  if (!plainRecord(outcome) || outcome.status !== 'ready') return null;
+  const payload = affectedPayload(outcome.raw, target);
+  return Array.isArray(payload?.affectedTests) ? [...payload.affectedTests].sort(compareText) : null;
+}
+
 function affectedTarget(raw, expectPath) {
   if (!plainRecord(raw) || !Array.isArray(raw.targets)) return null;
   const entry = raw.targets.find((candidate) => (
@@ -486,28 +505,43 @@ export function compileRuntimePlanV1(options = {}) {
   }
 
   // affected test drift検査（witness宣言とfresh affected観測のexact比較）。
+  //
+  // 比較はTODO単位で、そのTODOが持つ**全affected束縛の観測の和**に対して行う。1面しか持たない
+  // TODOでは束縛ごとの比較と同じ結果になり、複数面を所有するTODOでも表現できる——束縛ごとに
+  // 宣言全体とexact比較すると、affectedの異なる2 pathを所有するTODOは原理的に成立せず、
+  // 実行時に所有が広がった宣言を受け取れなくなる。和なので緩みは入らない（余分な宣言も
+  // 足りない宣言もdriftのまま）。
   const affectedDrift = [];
   for (const todoId of todoIds) {
     const witness = request.manual_witness[todoId];
+    const declared = [...witness.affected_tests].sort(compareText);
+    const queryIds = [];
+    const observedUnion = new Set();
+    let unreadable = false;
     for (const binding of bindingsByTodo.get(todoId)) {
       if (binding.expect.kind !== 'affected') continue;
       const outcome = outcomeByQueryId.get(binding.query_id);
       if (resolveBindingStatus(binding, outcome) !== 'ready') continue;
+      queryIds.push(binding.query_id);
       const payload = affectedPayload(outcome.raw, binding.expect.path);
-      const observed = Array.isArray(payload?.affectedTests)
-        ? [...payload.affectedTests].sort(compareText)
-        : null;
-      const declared = [...witness.affected_tests].sort(compareText);
-      if (observed === null
-        || observed.length !== declared.length
-        || observed.some((test, index) => test !== declared[index])) {
-        affectedDrift.push({
-          todo_id: todoId,
-          query_id: binding.query_id,
-          declared,
-          observed,
-        });
+      if (!Array.isArray(payload?.affectedTests)) {
+        // 観測が読めないのは「一致しない」とは別の事象である。丸めずそのまま残す。
+        affectedDrift.push({ todo_id: todoId, query_id: binding.query_id, declared, observed: null });
+        unreadable = true;
+        continue;
       }
+      for (const test of payload.affectedTests) observedUnion.add(test);
+    }
+    if (unreadable || queryIds.length === 0) continue;
+    const observed = [...observedUnion].sort(compareText);
+    if (observed.length !== declared.length
+      || observed.some((test, index) => test !== declared[index])) {
+      affectedDrift.push({
+        todo_id: todoId,
+        query_id: queryIds.sort(compareText).join(','),
+        declared,
+        observed,
+      });
     }
   }
   if (affectedDrift.length > 0) {

package/src/runtime-hold-recompile.mjs

@@ -1,4 +1,7 @@
 import { canonicalizeArtifact, digestArtifact } from './artifact-contracts.mjs';
+// 切断可能性の写像はtodo側と同じ正本を使う。計画時と実行時で「切れる種類」の定義が
+// 分かれると、同じ資源が段によって別の答えを持つ。
+import { severabilityOfConflictKind } from './todo-independence-contracts.mjs';
 import { buildNextRunEvent, buildExecutorPackets } from './runtime-engine.mjs';
 import { projectRuntimeState } from './runtime-projection.mjs';
 import {
@@ -594,20 +597,46 @@ export function detectNonConvergentConflicts(options = {}) {
   ));
 }
 
+/**
+ * 係争資源が構造的に切れる種類かを返す（ADR 0144の続き、請求項8の入口判定）。
+ *
+ * pathやsymbolは面を分ければ別々に所有できる。共有stateや外部effectは分けられない——
+ * 変換をどれだけ工夫しても同じ資源に触り続ける。**これは「切れる」ではなく「切れる種類だ」で
+ * あって、実際に切れるかは試して初めて分かる。**
+ */
+export function severabilityOfRuntimeFinding(finding) {
+  return severabilityOfConflictKind(typeof finding?.path === 'string' ? 'path' : 'state');
+}
+
+/**
+ * 競合をどちらの処置へ運ぶか（請求項7＝直列化／請求項8＝変換）。
+ *
+ * `seam_transform`を返すのは事前宣言済みtreatmentが係争pathを覆っている時だけである。
+ * それ以外の既定は直列化だが、**それは「変換が不可能」という意味ではない**。実行時に初めて
+ * 見つかった競合には事前宣言が無いので、既定だけを見ると請求項8へ行く道が無いように見える。
+ *
+ * そこで`severability`と`transform_attemptable`を併せて返す。装置が言えるのは「切れる種類の
+ * 資源か」までで、**実際の難しさは変換を試して五条件で測る**（`run seam resolve`）。試すかどうかは
+ * 費用のかかる判断なので装置が決めない——隔離worktreeでの変換、focused test、再indexを毎回
+ * 走らせるかは、操作するAIが持つ文脈で決める（AGENTS.md「装置の境界にAIを含める」）。
+ */
 export function routeConflictTreatment(options = {}) {
   if (!exactRecord(options, ['finding', 'predeclaredTreatments'])) {
     fail('routeConflictTreatment optionsがexact shapeでない');
   }
   const { finding, predeclaredTreatments } = options;
   if (!plainRecord(finding) || typeof finding.kind !== 'string') fail('findingが不正');
+  const severability = severabilityOfRuntimeFinding(finding);
   if (finding.kind === 'observed_write_conflict' && typeof finding.path === 'string') {
     for (const treatment of predeclaredTreatments) {
       if (Array.isArray(treatment.covered_paths) && treatment.covered_paths.includes(finding.path)) {
-        return { lane: 'seam_transform', treatment: structuredClone(treatment) };
+        return { lane: 'seam_transform', treatment: structuredClone(treatment),
+          severability, transform_attemptable: true };
       }
     }
   }
-  return { lane: 'intentional_serial', treatment: null };
+  return { lane: 'intentional_serial', treatment: null,
+    severability, transform_attemptable: severability === 'code_seam' };
 }
 
 /**