@quolu/lattice 0.1.0 → 0.12.2

package/src/rc2-delivery-policy-front-end.mjs

@@ -12,7 +12,7 @@ const INPUT_KEYS = [
   'manualEvidence',
   'querySet',
   'sourceSnapshot',
-  'codegraphEvidence',
+  'sensorEvidence',
 ];
 const EXPECTED_CANDIDATE_ID = 'shard-delivery-policy-registry-by-channel';
 const EXPECTED_ORACLE_DIGEST_BY_CANDIDATE_DIGEST = Object.freeze({
@@ -30,7 +30,7 @@ const QUERY_OPERATIONS = new Set([
   'impact',
   'affected',
 ]);
-const CODEGRAPH_OUTCOMES = new Set([
+const SENSOR_OUTCOMES = new Set([
   'ready',
   'symbol_absent',
   'empty',
@@ -106,7 +106,7 @@ function resourceId(kind, target) {
 
 function queryMapFor(querySet) {
   if (!exactRecord(querySet, ['schema', 'queries'])
-    || querySet.schema !== 'lattice.codegraph_query_set.v2') {
+    || querySet.schema !== 'lattice.sensor_query_set.v2') {
     fail('query set shapeまたはschemaが不正');
   }
   requireArray(querySet.queries, 'querySet.queries');
@@ -554,7 +554,7 @@ function validatePortableOutcomeShape(outcome, query) {
   if (!plainRecord(outcome)
     || outcome.id !== query.id
     || outcome.operation !== query.operation
-    || !CODEGRAPH_OUTCOMES.has(outcome.outcome)) {
+    || !SENSOR_OUTCOMES.has(outcome.outcome)) {
     fail(`portable outcome ${query.id} identityが不正`);
   }
   if (query.operation === 'status') {
@@ -609,7 +609,7 @@ function assertFreshStatus(statusOutcome) {
     || status.index.state !== 'complete'
     || status.index.pendingRefs !== 0
     || status.index.reindexRecommended !== false) {
-    fail('portable Codegraph statusがfresh／completeではない');
+    fail('portable LatticeSensor statusがfresh／completeではない');
   }
 }
 
@@ -642,13 +642,13 @@ function validateAffectedOutcome(outcome, query, filesByPath) {
 }
 
 function validatePortableEvidence({
-  codegraphEvidence,
+  sensorEvidence,
   querySet,
   queryById,
   candidateSpec,
   filesByPath,
 }) {
-  if (!exactRecord(codegraphEvidence, [
+  if (!exactRecord(sensorEvidence, [
     'schema',
     'projection',
     'query_set_digest',
@@ -656,22 +656,22 @@ function validatePortableEvidence({
     'per_query',
     'aggregate_digest',
   ])
-    || codegraphEvidence.schema !== 'lattice.codegraph_portable_preimage.v1'
-    || codegraphEvidence.projection !== 'lattice.codegraph_portable_outcome.v1'
-    || codegraphEvidence.query_set_digest !== digestArtifact(querySet)) {
+    || sensorEvidence.schema !== 'lattice.sensor_portable_preimage.v1'
+    || sensorEvidence.projection !== 'lattice.sensor_portable_outcome.v1'
+    || sensorEvidence.query_set_digest !== digestArtifact(querySet)) {
     fail('portable evidence identity／query bindingが不正');
   }
-  requireArray(codegraphEvidence.outcomes, 'portable.outcomes');
-  requireArray(codegraphEvidence.per_query, 'portable.per_query');
-  if (codegraphEvidence.outcomes.length !== querySet.queries.length
-    || codegraphEvidence.per_query.length !== querySet.queries.length) {
+  requireArray(sensorEvidence.outcomes, 'portable.outcomes');
+  requireArray(sensorEvidence.per_query, 'portable.per_query');
+  if (sensorEvidence.outcomes.length !== querySet.queries.length
+    || sensorEvidence.per_query.length !== querySet.queries.length) {
     fail('portable outcome件数がquery setと一致しない');
   }
   const byId = new Map();
   for (let index = 0; index < querySet.queries.length; index += 1) {
     const query = querySet.queries[index];
-    const outcome = codegraphEvidence.outcomes[index];
-    const receipt = codegraphEvidence.per_query[index];
+    const outcome = sensorEvidence.outcomes[index];
+    const receipt = sensorEvidence.per_query[index];
     validatePortableOutcomeShape(outcome, query);
     if (!exactRecord(receipt, ['id', 'operation', 'outcome', 'result_digest'])
       || receipt.id !== query.id
@@ -683,12 +683,12 @@ function validatePortableEvidence({
     byId.set(query.id, outcome);
   }
   const aggregatePreimage = {
-    projection: codegraphEvidence.projection,
-    query_set_digest: codegraphEvidence.query_set_digest,
-    outcomes: codegraphEvidence.outcomes,
+    projection: sensorEvidence.projection,
+    query_set_digest: sensorEvidence.query_set_digest,
+    outcomes: sensorEvidence.outcomes,
   };
-  if (!DIGEST.test(codegraphEvidence.aggregate_digest)
-    || codegraphEvidence.aggregate_digest !== digestArtifact(aggregatePreimage)) {
+  if (!DIGEST.test(sensorEvidence.aggregate_digest)
+    || sensorEvidence.aggregate_digest !== digestArtifact(aggregatePreimage)) {
     fail('portable aggregate digestがfull preimageから再計算できない');
   }
   assertFreshStatus(byId.get(candidateSpec.compiler_contract.status_query_id));
@@ -899,7 +899,7 @@ function structuralResources({
   candidateDigest,
   topology,
   outcomeById,
-  codegraphEvidence,
+  sensorEvidence,
 }) {
   const groups = new Map();
   const add = (kind, target, todoId, surface, ref) => {
@@ -958,12 +958,12 @@ function structuralResources({
     const queryIds = [...group.queryIds].sort(compareText);
     const outcomes = queryIds.map((id) => outcomeById.get(id));
     if (outcomes.some((outcome) => !outcome || outcome.outcome !== 'ready')) {
-      fail(`active resource ${group.kind}:${group.target}のCodegraph evidenceがreadyではない`);
+      fail(`active resource ${group.kind}:${group.target}のLatticeSensor evidenceがreadyではない`);
     }
     const evidenceDigest = digestArtifact({
-      schema: 'lattice.rc2.codegraph_resource_evidence.v1',
+      schema: 'lattice.rc2.sensor_resource_evidence.v1',
       topology,
-      portable_aggregate_digest: codegraphEvidence.aggregate_digest,
+      portable_aggregate_digest: sensorEvidence.aggregate_digest,
       query_ids: queryIds,
       outcomes,
     });
@@ -974,8 +974,8 @@ function structuralResources({
       todo_ids: [...group.todoIds].sort(compareText),
       provenance: [
         {
-          source: 'codegraph',
-          evidence_ref: `portable-codegraph#${queryIds.join(',')}`,
+          source: 'sensor',
+          evidence_ref: `portable-sensor#${queryIds.join(',')}`,
           evidence_digest: evidenceDigest,
           status: 'ready',
         },
@@ -1030,7 +1030,7 @@ export function compileDeliveryPolicyBoundaryBundleV2(inputs) {
     manualEvidence,
     querySet,
     sourceSnapshot,
-    codegraphEvidence,
+    sensorEvidence,
   } = inputs;
 
   if (!validatePlanInput(planInput)) fail('plan inputが不正');
@@ -1040,7 +1040,7 @@ export function compileDeliveryPolicyBoundaryBundleV2(inputs) {
   assertTodoBindings(planInput, candidateSpec, manualByTodo);
   const snapshot = validateSourceSnapshot(sourceSnapshot, candidateSpec);
   const outcomeById = validatePortableEvidence({
-    codegraphEvidence,
+    sensorEvidence,
     querySet,
     queryById,
     candidateSpec,
@@ -1055,7 +1055,7 @@ export function compileDeliveryPolicyBoundaryBundleV2(inputs) {
       candidateDigest,
       topology: snapshot.topology,
       outcomeById,
-      codegraphEvidence,
+      sensorEvidence,
     }),
     ...manualResources(manualByTodo, manualEvidenceDigest),
   ];

package/src/rc2-rc1-transfer-front-end.mjs

@@ -30,7 +30,7 @@ const QUERY_OPERATIONS = new Set([
   'impact',
   'affected',
 ]);
-const V2_CODEGRAPH_STATUSES = new Set([
+const V2_SENSOR_STATUSES = new Set([
   'ready',
   'symbol_absent',
   'empty',
@@ -119,7 +119,7 @@ function validateCandidateSpec(candidateSpec) {
 
 function queryMapFor(querySet) {
   if (!exactRecord(querySet, ['schema', 'queries'])
-    || querySet.schema !== 'lattice.codegraph_query_set.v2') {
+    || querySet.schema !== 'lattice.sensor_query_set.v2') {
     fail('query set shapeまたはschemaが不正');
   }
   requireArray(querySet.queries, 'querySet.queries');
@@ -341,8 +341,8 @@ function structuralResources({
     }
     const queryId = [...group.queryIds][0];
     const evidence = evidenceById.get(queryId);
-    if (!evidence || !V2_CODEGRAPH_STATUSES.has(evidence.status)) {
-      fail(`resource ${group.kind}:${group.target}のCodegraph statusをv2へ保持できない`);
+    if (!evidence || !V2_SENSOR_STATUSES.has(evidence.status)) {
+      fail(`resource ${group.kind}:${group.target}のLatticeSensor statusをv2へ保持できない`);
     }
     return {
       resource_id: resourceId(group.kind, group.target),
@@ -351,7 +351,7 @@ function structuralResources({
       todo_ids: [...group.todoIds].sort(compareText),
       provenance: [
         {
-          source: 'codegraph',
+          source: 'sensor',
           evidence_ref: `boundary-manifest.graph_evidence#${queryId}`,
           evidence_digest: evidence.result_digest,
           status: evidence.status,

package/src/rc3-actual-dogfood.mjs

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { digestArtifact } from './artifact-contracts.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
 import { scaffoldRc3DogfoodRepo, verifyRc3DogfoodScaffold } from './rc3-dogfood-scaffold.mjs';
 import { compileRuntimePlanV1, evidenceFromCollectedOutcomes } from './runtime-front-end.mjs';
 import {
@@ -95,7 +95,7 @@ function witness(todoId, target, affectedTests) {
     writes: [target],
     resources: [],
     state_effects: [],
-    codegraph_provenance: {
+    sensor_provenance: {
       queries: [{ query_id: `q-aff-${todoId}`, expect: { kind: 'affected', path: target } }],
     },
     affected_tests: affectedTests,
@@ -152,7 +152,7 @@ export async function initActualDogfoodRun({ latticeRoot, stateDir }) {
       { id: `probe-${index}`, operation: 'affected', target }
     )),
   };
-  const probed = await collectCodegraphEvidence({ cwd: scaffold.repoRoot, querySet: probeQuerySet });
+  const probed = await collectSensorEvidence({ cwd: scaffold.repoRoot, querySet: probeQuerySet });
   const affectedByTarget = {};
   probed.outcomes.forEach((outcome, index) => {
     const entry = Array.isArray(outcome.targets) ? outcome.targets[0] : null;
@@ -172,7 +172,7 @@ export async function initActualDogfoodRun({ latticeRoot, stateDir }) {
       TB: witness('TB', ORACLE, affectedByTarget[ORACLE]),
       TC: witness('TC', SHARED_TEST, affectedByTarget[SHARED_TEST]),
     },
-    codegraph_query_set: {
+    sensor_query_set: {
       queries: [
         { id: 'q-status', operation: 'status' },
         { id: 'q-aff-TA', operation: 'affected', target: ENTRY },
@@ -185,10 +185,10 @@ export async function initActualDogfoodRun({ latticeRoot, stateDir }) {
   };
   request.request_digest = selfDigest(request, 'request_digest');
 
-  const collected = await collectCodegraphEvidence({ cwd: scaffold.repoRoot, querySet: request.codegraph_query_set });
+  const collected = await collectSensorEvidence({ cwd: scaffold.repoRoot, querySet: request.sensor_query_set });
   const compiled = compileRuntimePlanV1({
     request,
-    codegraphEvidence: evidenceFromCollectedOutcomes({ querySet: request.codegraph_query_set, collected }),
+    sensorEvidence: evidenceFromCollectedOutcomes({ querySet: request.sensor_query_set, collected }),
     planRef: 'plan-rc3i-actual-e1',
     planEpoch: 1,
     predecessorRefs: [],

package/src/rc3-dogfood-scaffold.mjs

@@ -3,6 +3,8 @@ import { createHash } from 'node:crypto';
 import { lstat, mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
+import { invokeSensorCli } from './sensor-runtime.mjs';
+
 import { digestArtifact } from './artifact-contracts.mjs';
 
 /**
@@ -115,15 +117,16 @@ function runRaw(command, args, cwd) {
   });
 }
 
-// Lattice規約と同じく`.codegraph/.gitignore`（自身以外を無視）をtracked fileとして
-// commitへ含め、`codegraph init`後もtreeがcleanのままになるようにする。
-const CODEGRAPH_BOOTSTRAP_PATH = '.codegraph/.gitignore';
+// disposable repo自身のroot ignoreへ生成sensor stateを明示し、init後もtreeをcleanに保つ。
+// Lattice sourceのtracked bytesとは別物なのでsource provenanceへ混ぜない。
+const SENSOR_IGNORE_PATH = '.gitignore';
+const SENSOR_IGNORE_BYTES = Buffer.from('.lattice/sensor/\n', 'utf8');
 
 async function readLatticeSources(latticeRoot) {
   // bytesの正はHEAD blob（base commitへ束縛するため）。working treeが
   // HEADと食い違う場合は、dirty bytesをbase shaへ誤帰属させずrejectする。
   const bytesByPath = new Map();
-  for (const relativePath of [...RC3_DOGFOOD_SCAFFOLD_PATHS, CODEGRAPH_BOOTSTRAP_PATH]) {
+  for (const relativePath of RC3_DOGFOOD_SCAFFOLD_PATHS) {
     let headBytes;
     try {
       headBytes = await runRaw('git', ['show', `HEAD:${relativePath}`], latticeRoot);
@@ -181,6 +184,8 @@ export async function scaffoldRc3DogfoodRepo(options = {}) {
   }
   const repoRoot = path.join(workRoot, 'repo');
   const { bytesByPath, candidateDigest, oracleDigest } = await readLatticeSources(latticeRoot);
+  const targetBytesByPath = new Map(bytesByPath);
+  targetBytesByPath.set(SENSOR_IGNORE_PATH, SENSOR_IGNORE_BYTES);
   const latticeHead = (await run('git', ['rev-parse', 'HEAD'], latticeRoot)).stdout.trim();
   if (!GIT_SHA1.test(latticeHead)) fail('Lattice HEADを解決できない');
 
@@ -192,7 +197,7 @@ export async function scaffoldRc3DogfoodRepo(options = {}) {
     if (error?.code === 'EEXIST') fail(`repoRootが既に存在する（上書き禁止）: ${repoRoot}`);
     throw error;
   }
-  for (const [relativePath, bytes] of bytesByPath) {
+  for (const [relativePath, bytes] of targetBytesByPath) {
     const absolutePath = path.join(repoRoot, relativePath);
     await mkdir(path.dirname(absolutePath), { recursive: true });
     await writeFile(absolutePath, bytes);
@@ -202,7 +207,7 @@ export async function scaffoldRc3DogfoodRepo(options = {}) {
   await run('git', [...GIT_IDENTITY, 'commit', '--quiet', '-m', 'rc3 dogfood scaffold'], repoRoot);
   const baseSha = (await run('git', ['rev-parse', 'HEAD'], repoRoot)).stdout.trim();
   if (!GIT_SHA1.test(baseSha)) fail('scaffold base shaを解決できない');
-  await run('codegraph', ['init', '.'], repoRoot);
+  await invokeSensorCli(run, ['init', '.'], repoRoot);
 
   const status = await run('git', ['status', '--porcelain=v1', '--untracked-files=all'], repoRoot);
   if (status.stdout !== '') fail(`scaffold直後のtreeがcleanではない: ${status.stdout.trim()}`);
@@ -224,7 +229,7 @@ export async function scaffoldRc3DogfoodRepo(options = {}) {
     target: Object.freeze({
       root_kind: 'disposable-dogfood',
       base_sha: baseSha,
-      path_digests: Object.freeze(pathDigests(bytesByPath)),
+      path_digests: Object.freeze(pathDigests(targetBytesByPath)),
     }),
     predeclared_treatment: Object.freeze({
       epoch: EXPECTED_TREATMENT_EPOCH,

package/src/rc3-scripted-campaign.mjs

@@ -3,11 +3,13 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { digestArtifact } from './artifact-contracts.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
+import { spawnSensorCliSync } from './sensor-runtime.mjs';
 import { scaffoldRc3DogfoodRepo, verifyRc3DogfoodScaffold } from './rc3-dogfood-scaffold.mjs';
 import { compileRuntimePlanV1, evidenceFromCollectedOutcomes } from './runtime-front-end.mjs';
 import {
   adjudicatePendingReceipts,
+  buildNextRunEvent,
   buildExecutorPackets,
   classifyCheckpointObservation,
   closeRunIfComplete,
@@ -45,10 +47,11 @@ import { selfDigest } from './runtime-contracts.mjs';
  */
 
 const RUN_TIMESTAMP = '2026-07-17T00:00:00.000Z';
-// dogfood scaffoldの実在3 file（Codegraph観測がreadyになる対象）をTODO所有面にする。
+// dogfood scaffoldの実在3 file（LatticeSensor観測がreadyになる対象）をTODO所有面にする。
 const DOC_A = 'research/fixtures/delivery-policy-registry/src/delivery-policy-registry.mjs';
 const DOC_B = 'src/rc2-delivery-policy-oracle.mjs';
 const DOC_C = 'test/rc2-delivery-policy-fixture.test.mjs';
+const MAX_SCRIPTED_REBINDS = 64;
 
 function fail(reason) {
   throw new TypeError(`rc3 campaign契約違反: ${reason}`);
@@ -61,7 +64,7 @@ function docWitness(todoId, docPath, affectedTests, { extraWrites = [], unknowns
     writes: [docPath, ...extraWrites],
     resources: stateEffects.map(({ resource_id: id }) => id),
     state_effects: stateEffects,
-    codegraph_provenance: {
+    sensor_provenance: {
       queries: [{ query_id: `q-aff-${todoId}`, expect: { kind: 'affected', path: docPath } }],
     },
     affected_tests: affectedTests,
@@ -70,14 +73,14 @@ function docWitness(todoId, docPath, affectedTests, { extraWrites = [], unknowns
 }
 
 /**
- * manual witnessのaffected test宣言をfresh Codegraph観測から導出する
+ * manual witnessのaffected test宣言をfresh LatticeSensor観測から導出する
  * （宣言と観測のexact一致契約の下で、正解宣言を機械的に得る）。
  */
 async function probeAffectedTests(repoRoot, targets) {
   const querySet = {
     queries: targets.map((target, index) => ({ id: `probe-${index}`, operation: 'affected', target })),
   };
-  const collected = await collectCodegraphEvidence({ cwd: repoRoot, querySet });
+  const collected = await collectSensorEvidence({ cwd: repoRoot, querySet });
   const byTarget = {};
   collected.outcomes.forEach((outcome, index) => {
     const entry = Array.isArray(outcome.targets) ? outcome.targets[0] : null;
@@ -112,7 +115,7 @@ function buildDocRequest({ requestId, baseSha, todos, capacity }) {
     capacity: { executors: capacity },
     todos: Object.keys(todos).map((todoId) => ({ todo_id: todoId })),
     manual_witness: todos,
-    codegraph_query_set: { queries },
+    sensor_query_set: { queries },
     executor_capability: { adapters: ['isolated-worktree'] },
     claim_mode: 'exact_minimum',
   };
@@ -121,17 +124,17 @@ function buildDocRequest({ requestId, baseSha, todos, capacity }) {
 }
 
 async function compileForRepo({ request, repoRoot }) {
-  const collected = await collectCodegraphEvidence({
+  const collected = await collectSensorEvidence({
     cwd: repoRoot,
-    querySet: request.codegraph_query_set,
+    querySet: request.sensor_query_set,
   });
-  const codegraphEvidence = evidenceFromCollectedOutcomes({
-    querySet: request.codegraph_query_set,
+  const sensorEvidence = evidenceFromCollectedOutcomes({
+    querySet: request.sensor_query_set,
     collected,
   });
   return compileRuntimePlanV1({
     request,
-    codegraphEvidence,
+    sensorEvidence,
     planRef: `plan-${request.request_id}-e1`,
     planEpoch: 1,
     predecessorRefs: [],
@@ -188,6 +191,43 @@ async function driveToClose({ runId, plan, events, packets, manifests, adapter,
   return null;
 }
 
+/**
+ * legacy scripted campaign内だけで、controller rebindとactivation gateの完了を模擬する。
+ * productionのACK/gate検証を迂回する入口ではなく、既にscriptで完了させたactivationを
+ * event contractへ投影するための有界fixture helperである。
+ */
+function activateScriptedRecompile({ runId, events, plan, planDiff, rebindPackets }) {
+  const entries = Object.entries(rebindPackets).sort(([left], [right]) => left.localeCompare(right));
+  if (entries.length > MAX_SCRIPTED_REBINDS) {
+    fail(`scripted rebind数が上限を超えた: ${entries.length}`);
+  }
+  let next = [...events];
+  for (const [todoId, packet] of entries) {
+    if (packet?.todo_id !== todoId || packet?.new_plan_epoch !== plan.plan_epoch) {
+      fail(`scripted rebind packetの帰属が不正: ${todoId}`);
+    }
+    next.push(buildNextRunEvent({
+      events: next,
+      runId,
+      kind: 'epoch_rebound',
+      planEpoch: plan.plan_epoch,
+      subject: { kind: 'todo', ref: todoId },
+      payload: packet,
+      recordedAt: RUN_TIMESTAMP,
+    }));
+  }
+  next.push(buildNextRunEvent({
+    events: next,
+    runId,
+    kind: 'intake_resumed',
+    planEpoch: plan.plan_epoch,
+    subject: { kind: 'runtime_plan', ref: plan.plan_ref },
+    payload: { plan_diff_digest: planDiff.diff_digest },
+    recordedAt: RUN_TIMESTAMP,
+  }));
+  return next;
+}
+
 function decisionReplayChecks({ plan, events }) {
   const checks = [];
   events.forEach((event, index) => {
@@ -337,6 +377,13 @@ async function runLateConflict({ scaffold }) {
     executor_handle: projectRuntimeState({ events }).dispatches.TC.payload.executor_handle,
     rebind: recompiled.rebindPackets.TC,
   });
+  events = activateScriptedRecompile({
+    runId,
+    events,
+    plan: recompiled.newPlan,
+    planDiff: recompiled.planDiff,
+    rebindPackets: recompiled.rebindPackets,
+  });
   {
     const tcTerminal = await observeExecutor({
       runId, plan: recompiled.newPlan, events, adapter, todoId: 'TC', recordedAt: RUN_TIMESTAMP,
@@ -593,7 +640,7 @@ async function runAcceptedSeam({ latticeRoot }) {
     writes: [entryPath],
     resources: [],
     state_effects: [],
-    codegraph_provenance: {
+    sensor_provenance: {
       queries: [
         { query_id: 'q-entry', expect: { kind: 'symbol', name: 'resolveDeliveryPolicy', path: entryPath } },
         { query_id: 'q-aff-entry', expect: { kind: 'affected', path: entryPath } },
@@ -609,7 +656,7 @@ async function runAcceptedSeam({ latticeRoot }) {
     capacity: { executors: 2 },
     todos: [{ todo_id: 'Temail' }, { todo_id: 'Tsms' }],
     manual_witness: { Temail: preWitness(), Tsms: preWitness() },
-    codegraph_query_set: {
+    sensor_query_set: {
       queries: [
         { id: 'q-status', operation: 'status' },
         { id: 'q-entry', operation: 'query', target: 'resolveDeliveryPolicy' },
@@ -663,8 +710,8 @@ async function runAcceptedSeam({ latticeRoot }) {
   runGit(['-c', 'user.email=rc3h@lattice.invalid', '-c', 'user.name=rc3h', 'commit', '--quiet', '-m', 'accepted seam']);
   const newBase = runGit(['rev-parse', 'HEAD']).trim();
   // fresh reindex（accepted seam後は必ず再index。syncで新規fileを収載する）。
-  const syncResult = spawnSync('codegraph', ['sync', '.'], { cwd: scaffold.repoRoot, encoding: 'utf8' });
-  if (syncResult.status !== 0) fail(`codegraph reindex(sync)が失敗: ${syncResult.stderr}`);
+  const syncResult = spawnSensorCliSync(['sync', '.'], { cwd: scaffold.repoRoot, encoding: 'utf8' });
+  if (syncResult.status !== 0) fail(`sensor reindex(sync)が失敗: ${syncResult.stderr}`);
 
   const emailPath = 'research/fixtures/delivery-policy-registry/src/email-policy.mjs';
   const smsPath = 'research/fixtures/delivery-policy-registry/src/sms-policy.mjs';
@@ -675,7 +722,7 @@ async function runAcceptedSeam({ latticeRoot }) {
     writes: [filePath],
     resources: [],
     state_effects: [],
-    codegraph_provenance: {
+    sensor_provenance: {
       queries: [
         { query_id: `q-${todoId}`, expect: { kind: 'symbol', name: symbol, path: filePath } },
         { query_id: `q-aff-${todoId}`, expect: { kind: 'affected', path: filePath } },
@@ -694,7 +741,7 @@ async function runAcceptedSeam({ latticeRoot }) {
       Temail: postWitness('Temail', 'resolveEmailPolicy', emailPath),
       Tsms: postWitness('Tsms', 'resolveSmsPolicy', smsPath),
     },
-    codegraph_query_set: {
+    sensor_query_set: {
       queries: [
         { id: 'q-status', operation: 'status' },
         { id: 'q-Temail', operation: 'query', target: 'resolveEmailPolicy' },
@@ -710,13 +757,13 @@ async function runAcceptedSeam({ latticeRoot }) {
   // post-seam planはgenesisではなく、accepted transformとpre planをpredecessorに
   // 持つepoch 2 planとしてcompileする（Decision 11.2/plan barrier）。
   const transformArtifactDigest = digestArtifact(transformResult.artifact);
-  const postCollected = await collectCodegraphEvidence({
-    cwd: scaffold.repoRoot, querySet: postRequest.codegraph_query_set,
+  const postCollected = await collectSensorEvidence({
+    cwd: scaffold.repoRoot, querySet: postRequest.sensor_query_set,
   });
   const postCompiled = compileRuntimePlanV1({
     request: postRequest,
-    codegraphEvidence: evidenceFromCollectedOutcomes({
-      querySet: postRequest.codegraph_query_set, collected: postCollected,
+    sensorEvidence: evidenceFromCollectedOutcomes({
+      querySet: postRequest.sensor_query_set, collected: postCollected,
     }),
     planRef: `plan-${postRequest.request_id}-e2`,
     planEpoch: 2,
@@ -840,6 +887,13 @@ async function runIrreducibleConflict({ scaffold }) {
   });
   events = recompiled.events;
   const newPlan = recompiled.newPlan;
+  events = activateScriptedRecompile({
+    runId,
+    events,
+    plan: newPlan,
+    planDiff: recompiled.planDiff,
+    rebindPackets: recompiled.rebindPackets,
+  });
   // vN+1でserial redispatch（conflict pairは同時に載らない）。
   const epoch2Adapter = createScriptedExecutorAdapter({
     script: { TA: [{ kind: 'terminal' }], TB: [{ kind: 'terminal' }] },

package/src/rc4-stage1-dogfood.mjs

@@ -1,10 +1,11 @@
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { mkdir, mkdtemp, readFile, rename, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { digestArtifact } from './artifact-contracts.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
 import { compileRuntimePlanV1, evidenceFromCollectedOutcomes } from './runtime-front-end.mjs';
 import {
   adjudicatePendingReceipts,
@@ -142,7 +143,7 @@ function stateAdapter(state) {
 }
 
 /**
- * step 1: request読込・codegraph evidence収集・compile・全TODO dispatch
+ * step 1: request読込・sensor evidence収集・compile・全TODO dispatch
  * （worktree provision）まで。返り値のworktree pathsへ、親が実agentを
  * dispatchする。packetにはisolation_contractが含まれる。
  */
@@ -151,11 +152,11 @@ export async function initStage1Run({ latticeRoot, cloneRoot, requestPath, state
   const request = JSON.parse(await readFile(requestPath, 'utf8'));
   if (!validateRunRequest(request)) fail('run_requestがlattice.run_request.v1 contractを満たさない');
 
-  const collected = await collectCodegraphEvidence({ cwd: cloneRoot, querySet: request.codegraph_query_set });
-  const codegraphEvidence = evidenceFromCollectedOutcomes({ querySet: request.codegraph_query_set, collected });
+  const collected = await collectSensorEvidence({ cwd: cloneRoot, querySet: request.sensor_query_set });
+  const sensorEvidence = evidenceFromCollectedOutcomes({ querySet: request.sensor_query_set, collected });
   const compiled = compileRuntimePlanV1({
     request,
-    codegraphEvidence,
+    sensorEvidence,
     planRef: `plan-${request.request_id}-e1`,
     planEpoch: 1,
     predecessorRefs: [],
@@ -379,6 +380,9 @@ export async function terminalStage1Receipt({ stateDir, todoId, planKey }) {
     checkpoint_digest: lastCheckpoint.checkpoint_digest,
     paths: receipt.observed_diff.map(({ path: p }) => p),
     patch: patchBytes,
+    // ADR 0051 Decision 4: path一致だけではpatch本文の取り違え・破損を検出できない。
+    // 捕獲bytesのdigestを併記し、verifierが保存bytesから再計算して束縛を検査する。
+    patch_sha256: createHash('sha256').update(patchBytes).digest('hex'),
   };
   let cleanup = { cleanup_ok: true, residual_paths: [] };
   try {
@@ -630,13 +634,26 @@ export async function verifyStage1ArtifactOnDisk({ artifactRoot }) {
       receiptByld.set(event.payload.receipt_id, event);
     }
     const receiptEvents = events.filter((event) => event.kind === 'receipt_recorded');
-    const patchesOk = [...receiptByld.keys()].every((receiptId) => {
+    // ADR 0051 Decision 4の強化: path照合に加え、(a) checkpoint_digest／todo_idを
+    // receipt_recorded payloadと照合し、(b) patch bytesのsha256を再計算して保存digestと
+    // 突合する。(b)は世代判定＝1 entryでもpatch_sha256を持つartifactは全entryへ必須
+    // （旧v4-landing世代＝全entry不在は(a)までで検査し、per-entryのfail-openを作らない）。
+    const patchEntries = Object.values(patches);
+    const shaGeneration = patchEntries.some((entry) => entry.patch_sha256 !== undefined);
+    const patchesOk = patchEntries.length > 0 && [...receiptByld.keys()].every((receiptId) => {
       const patch = patches[receiptId];
       if (patch === undefined || typeof patch.patch !== 'string' || patch.patch.length === 0) return false;
       const recorded = receiptEvents.find((event) => event.payload.receipt_id === receiptId);
       if (recorded === undefined) return false;
+      if (patch.checkpoint_digest !== recorded.payload.checkpoint_digest) return false;
+      if (patch.todo_id !== recorded.payload.todo_id) return false;
       const receiptPaths = [...recorded.payload.observed_diff.map(({ path: p }) => p)].sort();
-      return JSON.stringify([...patch.paths].sort()) === JSON.stringify(receiptPaths);
+      if (JSON.stringify([...patch.paths].sort()) !== JSON.stringify(receiptPaths)) return false;
+      if (shaGeneration) {
+        if (typeof patch.patch_sha256 !== 'string') return false;
+        return createHash('sha256').update(patch.patch).digest('hex') === patch.patch_sha256;
+      }
+      return true;
     });
     checks.push({ id: 'patches_bound_to_accepted_receipts', passed: patchesOk });
   }