@quolu/lattice 0.28.0 → 0.30.0

package/src/runtime-cli.mjs

@@ -20,6 +20,10 @@ import { fileURLToPath } from 'node:url';
 import { canonicalizeArtifact, digestArtifact } from './artifact-contracts.mjs';
 import { collectSensorEvidence } from './sensor-adapter.mjs';
 import { detectCheckpointFindings } from './runtime-diff-observer.mjs';
+import {
+  buildIoEscalation, createRunSentinel, probeIoWarning, syncSentinelWatches,
+} from './runtime-io-sentinel.mjs';
+import { ensureScriptedWorktree, removeScriptedWorktrees } from './runtime-scripted-worktree.mjs';
 import {
   buildRuntimeSeamResolution, readRuntimeFindingRecord, resolveRuntimeSeam,
   validateRuntimeSeamRequest, verifySeamSplitSuccessor,
@@ -126,6 +130,15 @@ const CLI_ERROR_SCHEMA = 'lattice.cli_error.v2';
 const RUN_STORE_ROOT = ['.lattice', 'runs'];
 const RUN_REF = /^\.lattice\/runs\/([0-9A-Za-z](?:[0-9A-Za-z._-]{0,127}))$/u;
 const KNOWN_ADAPTERS = Object.freeze(['scripted', 'isolated-worktree', 'actual-agent']);
+/**
+ * 自動escalationがlifecycle lockを待つ上限（ADR 0143）。
+ *
+ * 待つのは、警報が飛んだ瞬間にactivateやrecompileが走っていることが普通にあるからである。
+ * 待たずに諦めると、早期警報がいちばん効く場面——複数TODOが同時に動いている最中——で
+ * 必ず取り逃す。上限を置くのは、待ち続けてdaemonの他の仕事を止めないため。
+ * 超えたら`rejected`として理由ごとjournalへ残す（黙って見送らない）。
+ */
+const IO_ESCALATION_LOCK_TIMEOUT_MS = 15_000;
 
 class CliContractError extends Error {
   constructor(code, message, detail) {
@@ -736,6 +749,7 @@ async function driveInitialScriptedManagedEpoch({
   managedSupervisor,
   initialEvents,
   controlEvents,
+  sentinel = null,
 }) {
   let events = [...initialEvents];
   const { plan, manifests, executor_packets: packets } = committed.bundle;
@@ -758,6 +772,17 @@ async function driveInitialScriptedManagedEpoch({
         'initial dispatch leaseのcontrol bindingが無い',
       );
     }
+    // workerの木を先に用意し、**dispatchの前から**監視を張る。dispatch応答を待つと、
+    // 応答の中で書き込みが終わっている構成では観測対象のイベントが一度も起きない。
+    // 木がTODOごとに分かれて初めて、書き込みの帰属をrootから決められる。
+    const worktreeByTodo = new Map();
+    for (const todoId of frontier) {
+      worktreeByTodo.set(todoId, await ensureScriptedWorktree({
+        repoRoot, runDir, packet: packets[todoId],
+      }));
+    }
+    syncSentinelWatches({ sentinel, runningTodoIds: [...frontier],
+      rootOf: (todoId) => worktreeByTodo.get(todoId) });
     const stagedLeases = [];
     for (const todoId of frontier) {
       const packet = packets[todoId];
@@ -833,7 +858,8 @@ async function driveInitialScriptedManagedEpoch({
             process_group_id: processGroupId,
             process_start_identity:
               structuredClone(activation.controllerDescriptor.process_start_identity),
-            worktree_path: repoRoot,
+            // TODOごとの木を指す。ここがrepo rootだった頃、帰属はrootから決まらなかった。
+            worktree_path: worktreeByTodo.get(packet.todo_id),
             base_sha: packet.base_sha,
           },
         };
@@ -879,6 +905,12 @@ async function driveInitialScriptedManagedEpoch({
     }
     events = dispatched.events;
     await replaceEventsAtomically(runDir, events);
+    // 走り出した瞬間から見る。checkpointは完了時まで撮られないので、ここを逃すと
+    // 早期警報の意味が無くなる。
+    syncSentinelWatches({ sentinel, runningTodoIds: projectRuntimeState({ events }).running,
+      rootOf: (todoId) => events.findLast((event) => event.kind === 'executor_dispatched'
+        && event.subject?.kind === 'todo' && event.subject.ref === todoId)
+        ?.payload?.direct_os_observation_binding?.worktree_path });
     for (const todoId of dispatched.dispatched) {
       const observed = await observeExecutor({
         runId: request.request_id,
@@ -890,6 +922,10 @@ async function driveInitialScriptedManagedEpoch({
       });
       events = observed.events;
       await replaceEventsAtomically(runDir, events);
+      syncSentinelWatches({ sentinel, runningTodoIds: projectRuntimeState({ events }).running,
+        rootOf: (todoId) => events.findLast((event) => event.kind === 'executor_dispatched'
+          && event.subject?.kind === 'todo' && event.subject.ref === todoId)
+          ?.payload?.direct_os_observation_binding?.worktree_path });
     }
     const adjudicated = adjudicatePendingReceipts({
       runId: request.request_id,
@@ -1686,6 +1722,7 @@ export async function runManagedSupervisorDaemon({
     clock: canonicalNow });
   let eventStore = requestStore;
   let server;
+  let sentinel = null;
 
   const appendControl = async ({ run_id: runId, kind, session_nonce_digest: sessionDigest, payload }) => {
     const eventDigest = await eventStore.append({ run_id: runId, kind,
@@ -1694,6 +1731,230 @@ export async function runManagedSupervisorDaemon({
     return eventDigest;
   };
   let gateWriter = null;
+
+  /**
+   * 警報を無停止のcheckpointで確かめる（ADR 0143の二段目）。
+   *
+   * probeが撮るのはgitから読んだ本物のdiffなので、そのままfindingの証拠になる。
+   * fs eventをfindingへ昇格させる必要が無く、契約を1つも緩めずに済む。
+   */
+  const probeWarning = async (warning) => {
+    const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events')
+      .catch(() => null);
+    if (!Array.isArray(events)) {
+      return { outcome: 'unprobed', writers: [], checkpoints: {}, roots: {} };
+    }
+    const checkpoints = {};
+    const roots = {};
+    for (const todoId of warning.todo_ids) {
+      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;
+      if (typeof binding?.worktree_path !== 'string' || typeof binding?.base_sha !== 'string') continue;
+      roots[todoId] = binding.worktree_path;
+      // 観測できないTODOは「書いていない」へ丸めない。probeIoWarningが未観測として扱う。
+      const captured = await captureWorktreeDiff({
+        worktreePath: binding.worktree_path, baseSha: binding.base_sha,
+      }).catch(() => null);
+      if (captured !== null) checkpoints[todoId] = captured;
+    }
+    if (Object.keys(checkpoints).length === 0) {
+      return { outcome: 'unprobed', writers: [], checkpoints, roots };
+    }
+    return { ...probeIoWarning({ warning, checkpointsByTodo: checkpoints }), checkpoints, roots };
+  };
+
+  /**
+   * 書き手を特定できる構成かを確かめる。
+   *
+   * sentinelの帰属はworktree rootだけで決まる（プロセス帰属を持たない）。だから
+   * **複数TODOが同じrootを共有している構成では、誰が書いたかを観測から言えない**。
+   * 実際、管理daemonのscripted構成は全TODOのbindingが同じrepo rootを指す。
+   *
+   * そこでは警報も、probeが撮るcheckpointも、TODO間で区別が付かない——同じ木を2回読んで
+   * 「両方が書いた」と読めてしまう。これをholdへ繋ぐと、無実のTODOを止める。
+   * 帰属が立たないならescalationへ進めない。警報と実在の記録はそのまま残す。
+   */
+  const attributionIsDistinct = (warning, roots) => {
+    const paths = warning.todo_ids.map((todoId) => roots[todoId]);
+    if (paths.some((value) => typeof value !== 'string')) return false;
+    return new Set(paths).size === paths.length;
+  };
+
+  /**
+   * I/O sentinelの早期警報を耐久化する（ADR 0143）。
+   *
+   * **findingにはしない。** findingの契約はcheckpoint digestを必須にしており、それはfindingが
+   * 事後に再読して再導出できる主張であることの担保である。fs eventは取りこぼすし再読もできない。
+   * ここで残すのは「機械が気づいた」という事実だけで、判定の正本はcheckpointのままである。
+   *
+   * 記録しない選択肢は無い。気づいたのに黙っている状態を残さない（ADR 0130）。
+   */
+  const warningDigestOf = (warning) => digestArtifact({
+    warning_kind: warning.kind, todo_ids: [...warning.todo_ids].sort(), path: warning.path,
+  });
+
+  const recordIoWarning = async (warning, probeOutcome) => {
+    const payload = {
+      warning_kind: warning.kind,
+      todo_ids: [...warning.todo_ids].sort(),
+      path: warning.path,
+      probe_outcome: probeOutcome,
+      warning_digest: warningDigestOf(warning),
+    };
+    await appendControl({ run_id: request.request_id, kind: 'io_warning_observed',
+      session_nonce_digest: digestArtifact(sessionNonce), payload });
+  };
+
+  /**
+   * probeが撮ったcheckpointをrun eventへ耐久化する（ADR 0143の三段目・前段）。
+   *
+   * `finding_record`はcheckpointがactive epochのevent prefixから解決できることを要求する。
+   * probeのcheckpointは他のcheckpointと同じくgitから読んだ実diffなので、findingの証拠に
+   * そのまま使える。ただし**由来は印として残す**——これはexecutorの申告境界ではなく
+   * supervisorが選んだ走行中の一点であり、receipt裁定のbinding基準に混ぜると、
+   * probe後も書き続けた正当なreceiptがcheckpoint_mismatchで落ちる。
+   * events.jsonは全体置換なので、lifecycle lockの内側でだけ触る。
+   *
+   * @returns {{ok: true, expected_epoch: number}|{ok: false, outcome: string, detail: string}}
+   */
+  const durablyRecordProbeCheckpoints = async (escalation, checkpointsByTodo) => {
+    let lock;
+    try {
+      lock = await acquireRuntimeLifecycleLock({ runDir,
+        sessionNonceDigest: digestArtifact(sessionNonce), operation: 'finding_record',
+        requestId: `${escalation.escalation_id}.checkpoint`,
+        timeoutMs: IO_ESCALATION_LOCK_TIMEOUT_MS, retryIntervalMs: 25 });
+    } catch (error) {
+      return { ok: false, outcome: 'rejected',
+        detail: `lifecycle lockを取れない: ${error?.code ?? 'RUN_BUSY'}` };
+    }
+    try {
+      const active = await readCommittedEpochStore(runDir);
+      if (active === null) return { ok: false, outcome: 'skipped', detail: 'managed epochが未commit' };
+      const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
+      const state = projectRuntimeState({ events });
+      // 既にfreeze済みなら、この警報が指す競合はもう止まっている。二重にholdを掛けない。
+      if (state.freeze !== null) {
+        return { ok: false, outcome: 'skipped', detail: 'runは既にfreeze済み' };
+      }
+      // 走り終わったTODOはcheckpoint findingが従来どおり捕まえる。早期警報の出番ではない。
+      const running = new Set(state.running);
+      if (!escalation.writers.every((todoId) => running.has(todoId))) {
+        return { ok: false, outcome: 'skipped', detail: '観測したTODOが既にrunningでない' };
+      }
+      let next = events;
+      for (const todoId of escalation.writers) {
+        const checkpoint = checkpointsByTodo[todoId];
+        if (next.some((event) => event.kind === 'checkpoint_observed'
+          && event.payload?.checkpoint_digest === checkpoint.checkpoint_digest)) continue;
+        next = [...next, buildNextRunEvent({ events: next, runId: request.request_id,
+          kind: 'checkpoint_observed', planEpoch: active.pointer.plan_epoch,
+          subject: { kind: 'todo', ref: todoId },
+          payload: { ...structuredClone(checkpoint), observed_by: 'supervisor_probe' },
+          recordedAt: canonicalNow() })];
+      }
+      if (next !== events) await replaceEventsAtomically(runDir, next);
+      return { ok: true, expected_epoch: active.pointer.plan_epoch };
+    } catch (error) {
+      return { ok: false, outcome: 'rejected',
+        detail: `probe checkpointを耐久化できない: ${error?.code ?? String(error?.message ?? error)}` };
+    } finally {
+      await lock.release();
+    }
+  };
+
+  /**
+   * probeが実在と判定した警報を、既存のhold経路へ入れる（ADR 0143の三段目）。
+   *
+   * **新しい停止経路を作らない。** daemon自身が、hostが叩くのとまったく同じ
+   * `finding_record`→`conflict`→`hold`をcontrol requestとして発行する。findingの再導出も、
+   * epoch束縛も、durable evidenceの照合も、既存handlerがそのまま行う——早期警報が短くするのは
+   * **気づくまでの時間**だけで、通す関門は1つも減らない。
+   *
+   * 途中で断られたらそこで止め、理由をjournalへ残す。静かに別経路へ逃げない。
+   */
+  const escalateIoWarning = async (warning, probed, packets) => {
+    const built = buildIoEscalation({ warning, probe: probed,
+      checkpointsByTodo: probed.checkpoints, packets });
+    if (built === null) return null;
+    const escalation = { ...built, escalation_id: `io-esc-${randomUUID()}` };
+    const decide = async (outcome, detail, findingDigest = null) => {
+      await appendControl({ run_id: request.request_id, kind: 'io_escalation_decided',
+        session_nonce_digest: digestArtifact(sessionNonce), payload: {
+          warning_digest: warningDigestOf(warning),
+          anchor_todo_id: escalation.anchor_todo_id,
+          checkpoint_digest: escalation.checkpoint_digest,
+          finding_digest: findingDigest, outcome, detail,
+        } });
+      return { outcome, detail, finding_digest: findingDigest };
+    };
+    if (!attributionIsDistinct(warning, probed.roots)) {
+      return decide('skipped',
+        'worktree rootを共有する構成では書き手を特定できない（帰属はrootだけで決まる）');
+    }
+    const recorded = await durablyRecordProbeCheckpoints(escalation, probed.checkpoints);
+    if (!recorded.ok) return decide(recorded.outcome, recorded.detail);
+
+    const submit = async (operation, { artifact = null, artifactDigest = null,
+      checkpointDigest = null } = {}) => {
+      const controlRequest = createRuntimeControlRequest({
+        requestId: `${escalation.escalation_id}.${operation.replace(/_/gu, '-')}`,
+        runId: request.request_id, operation, sessionNonce,
+        payload: controlOperationPayload({ operation, runRef: request.request_id,
+          artifact, artifactDigest, checkpointDigest,
+          expectedEpoch: recorded.expected_epoch, expectedQueueDigest: null }),
+      });
+      return handler(controlRequest);
+    };
+    const unmetOf = (response) => (response?.result?.unmet ?? []).join('/')
+      || String(response?.outcome ?? 'unknown');
+
+    const findingResponse = await submit('finding_record', {
+      artifact: escalation.candidate, artifactDigest: escalation.candidate.candidate_digest,
+      checkpointDigest: escalation.checkpoint_digest,
+    }).catch((error) => ({ outcome: 'rejected',
+      result: { unmet: [String(error?.code ?? error?.message ?? error)] } }));
+    const findingDigest = findingResponse?.result?.finding_digest ?? null;
+    if (findingResponse?.outcome !== 'completed' || !/^[0-9a-f]{64}$/u.test(findingDigest ?? '')) {
+      return decide('rejected', `finding_recordが通らない: ${unmetOf(findingResponse)}`);
+    }
+
+    const conflictResponse = await submit('conflict', { artifactDigest: findingDigest })
+      .catch((error) => ({ outcome: 'rejected',
+        result: { unmet: [String(error?.code ?? error?.message ?? error)] } }));
+    if (conflictResponse?.outcome !== 'completed') {
+      return decide('rejected', `conflictが通らない: ${unmetOf(conflictResponse)}`, findingDigest);
+    }
+
+    const holdResponse = await submit('hold').catch((error) => ({ outcome: 'rejected',
+      result: { unmet: [String(error?.code ?? error?.message ?? error)] } }));
+    if (holdResponse?.outcome !== 'completed') {
+      return decide('rejected', `holdが通らない: ${unmetOf(holdResponse)}`, findingDigest);
+    }
+    return decide('held', `早期警報からhold: ${warning.kind}/${warning.path}`, findingDigest);
+  };
+
+  /**
+   * 警報1件の全行程（probe → 記録 → escalation）。
+   *
+   * probeが`observed`でも、escalationは走らないことがある（既にfreeze済み、当該TODOが
+   * 走り終わっている）。その差を`probe_outcome`で区別する——`escalated`はhold経路へ
+   * 渡したことまでを言い、渡さなかったなら`observed`のまま残す。
+   */
+  const handleIoWarning = async (warning, packets) => {
+    const probed = await probeWarning(warning).catch(() => (
+      { outcome: 'unprobed', writers: [], checkpoints: {} }));
+    const decided = probed.outcome === 'observed'
+      ? await escalateIoWarning(warning, probed, packets).catch(() => null)
+      : null;
+    await recordIoWarning(warning,
+      decided === null || decided.outcome === 'skipped' ? probed.outcome : 'escalated');
+  };
+
+  /** 警報の処理を直列化する鎖。`onWarning`はここへ繋ぐだけにする。 */
+  let escalationChain = Promise.resolve();
+
   const resolveObservationBinding = async ({ binding }) => {
     const events = await readBoundedJson(path.join(runDir, 'events.json'), 'run events');
     const dispatch = events.findLast((event) => event.kind === 'executor_dispatched'
@@ -1805,6 +2066,20 @@ export async function runManagedSupervisorDaemon({
           await extra.registerWithManagedSupervisor(managedSupervisor);
         }
         if (!restarting && isDistributedScriptedControllerActivation(activation)) {
+          sentinel = createRunSentinel({
+            packets: committed.bundle.executor_packets,
+            onWarning: (warning) => {
+              // escalationはrun全体の状態（events.json・lifecycle lock・freeze）を触るので、
+              // 警報が同時に何本飛んでも1本ずつ処理する。並べると、同じcheckpointを二重に
+              // 積んだり、holdが掛かった後の警報でもう一度holdを試したりする。
+              const settled = escalationChain.then(() => handleIoWarning(warning,
+                committed.bundle.executor_packets));
+              // 鎖自体は必ずresolvedへ戻す（1件の失敗で以後の警報を止めない）。
+              // 失敗そのものは呼び出し側へ返す方を残し、握り潰さない。
+              escalationChain = settled.catch(() => {});
+              return settled;
+            },
+          });
           await driveInitialScriptedManagedEpoch({
             runDir,
             repoRoot,
@@ -1812,6 +2087,7 @@ export async function runManagedSupervisorDaemon({
             committed,
             activation,
             managedSupervisor,
+            sentinel,
             initialEvents: events,
             controlEvents: () => controlEvents,
           });
@@ -2577,6 +2853,11 @@ export async function runManagedSupervisorDaemon({
             recordedAt: canonicalNow() })];
         }
         await replaceEventsAtomically(runDir, events);
+        // abandonは成果を捨てる決定なので、workerの木も畳む。closeでは畳まない——
+        // 木そのものがrunの成果であり、着地させる前に消したら受理した内容が残らない。
+        if (controlRequest.operation === 'abandon') {
+          await removeScriptedWorktrees({ repoRoot, runDir }).catch(() => null);
+        }
         await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
           session_nonce_digest: digestArtifact(sessionNonce),
           payload: { shutdown_result_digest: shutdown.result_digest } });
@@ -3095,6 +3376,9 @@ export async function runManagedSupervisorDaemon({
   };
   server = await serveRuntimeControlSocket({ socketPath, handler });
   registerDaemonCleanup(async (signal) => {
+    // 監視fdを残さない。取り残すとtest fixtureの後片付けが重くなる。
+    sentinel?.close();
+    sentinel = null;
     if (activationCommitted && activation !== null) {
       await appendControl({ run_id: request.request_id, kind: 'supervisor_stopped',
         session_nonce_digest: digestArtifact(sessionNonce), payload: { signal } });

package/src/runtime-control-store.mjs

@@ -156,6 +156,36 @@ export function validateRuntimeControlEventPayload(kind, value) {
   if (kind === 'supervisor_recovery_barrier') {
     return exact(value, ['barrier_id']) && identifier(value.barrier_id);
   }
+  // I/O sentinelの早期警報（ADR 0143）。**findingではない**——検知の正本はcheckpointのままで、
+  // これは「早くcheckpointを撮って確かめろ」という引き金の記録である。記録しない選択肢は無い:
+  // 機械が何かに気づいたのに黙っている状態を残さない（ADR 0130）。
+  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)
+      && 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)
+      && typeof value.path === 'string' && value.path.length > 0 && value.path.length <= 4096
+      && ['observed', 'transient', 'escalated', 'unprobed'].includes(value.probe_outcome)
+      && value.warning_digest === canonicalDigest({
+        warning_kind: value.warning_kind, todo_ids: value.todo_ids, path: value.path,
+      });
+  }
+  // probeを通った警報を既存hold経路へ入れた顛末（ADR 0143の三段目）。
+  // 成否どちらも残す。自動escalationが黙って失敗する状態を作らない——失敗の理由は
+  // `detail`が持ち、これが無いと「警報は出たのにholdが掛かっていない」を後から説明できない。
+  if (kind === 'io_escalation_decided') {
+    return exact(value, ['warning_digest', 'anchor_todo_id', 'checkpoint_digest',
+      'finding_digest', 'outcome', 'detail'])
+      && digest(value.warning_digest) && identifier(value.anchor_todo_id)
+      && digest(value.checkpoint_digest)
+      && (value.finding_digest === null || digest(value.finding_digest))
+      && ['held', 'rejected', 'skipped'].includes(value.outcome)
+      // holdまで通ったなら、どのfindingで止めたかを必ず指す。途中で落ちた時は
+      // 記録済みfindingがあればそれを残す（無ければnull）——後追いの手掛かりを捨てない。
+      && (value.outcome !== 'held' || digest(value.finding_digest))
+      && typeof value.detail === 'string' && value.detail.length > 0 && value.detail.length <= 4096;
+  }
   return false;
 }
 

package/src/runtime-decision-verifier.mjs

@@ -487,6 +487,9 @@ export function recomputeReceiptDecisions(options = {}) {
       entry.todo_id === receipt.todo_id
       && entry.sequence > dispatch.sequence
       && entry.sequence < receipt.sequence
+      // supervisorがI/O警報を確かめるために撮ったcheckpointはexecutorの申告境界では
+      // ないので、bindingの基準にしない（ADR 0143。engine側と同一規則）。
+      && entry.payload?.observed_by !== 'supervisor_probe'
     ));
     if (observedCheckpoints.length > 0) {
       const last = observedCheckpoints[observedCheckpoints.length - 1].payload;

package/src/runtime-diff-observer.mjs

@@ -238,7 +238,14 @@ export async function captureWorktreeDiff(options = {}) {
   };
 }
 
-function coveredBy(declaredWrites, observedPath) {
+/**
+ * 宣言writeがobserved pathを覆うか。末尾`/`はprefixとして読む。
+ *
+ * I/O sentinelの早期警報も同じ述語を使う（ADR 0143）。警報とcheckpoint findingで
+ * 述語が分かれると、「警報は出たがcheckpointでは競合にならない」種類のずれが生まれ、
+ * どちらが正しいのか誰にも分からなくなる。
+ */
+export function coveredBy(declaredWrites, observedPath) {
   return declaredWrites.some((declared) => (
     declared === observedPath
     || (declared.endsWith('/') && observedPath.startsWith(declared))

package/src/runtime-engine.mjs

@@ -619,6 +619,11 @@ export function adjudicatePendingReceipts(options = {}) {
         entry.todo_id === receipt.todo_id
         && entry.sequence > attemptStart
         && entry.sequence < receipt.sequence
+        // supervisorが自分の判断で撮ったcheckpoint（I/O警報のprobe）は、executorの
+        // 申告境界ではない。走行中の任意の一点なので、その後も書き続けたexecutorの
+        // receiptと一致しないのが正常である。ここへ混ぜると、正当なreceiptが
+        // checkpoint_mismatchで落ちる。証拠としては残り、findingの導出には使われる。
+        && entry.payload?.observed_by !== 'supervisor_probe'
       ));
       if (observedCheckpoints.length === 0) return false;
       const last = observedCheckpoints[observedCheckpoints.length - 1].payload;