@quolu/lattice 0.1.0 → 0.12.2

package/src/rc1-v6-measurement.mjs

@@ -1,8 +1,6 @@
 import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { constants as fsConstants } from 'node:fs';
 import {
-  access,
   lstat,
   readFile,
   realpath,
@@ -20,6 +18,7 @@ import {
   createRc1V6EvidenceBundleDescriptor,
   verifyRc1V6RunEvidence,
 } from './rc1-v6-causal-binding.mjs';
+import { LATTICE_SENSOR_CLI } from './sensor-runtime.mjs';
 
 const SHA256 = /^[0-9a-f]{64}$/;
 const GIT_SHA1 = /^[0-9a-f]{40}$/;
@@ -78,7 +77,7 @@ function validateSourceSnapshot(value) {
     && value.files.every(validSnapshotFile);
 }
 
-/** behavior fixed surfaceをCodegraph measurement用source snapshotへ投影する。 */
+/** behavior fixed surfaceをLatticeSensor measurement用source snapshotへ投影する。 */
 export function sourceSnapshotFromRc1BehaviorSurface(surface) {
   if (!exactRecord(surface, ['schema', 'files'])
     || surface.schema !== 'lattice.rc1.behavior_surface_snapshot.v1'
@@ -162,40 +161,23 @@ export async function captureRc1V6SourceSnapshot({ repoRoot, paths } = {}) {
   return sourceSnapshot(files);
 }
 
-async function resolveExecutable(command) {
-  const pathEntries = String(process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
-  for (const directory of pathEntries) {
-    const candidate = path.join(directory, command);
-    try {
-      await access(candidate, fsConstants.X_OK);
-      const resolved = await realpath(candidate);
-      const stat = await lstat(resolved);
-      if (stat.isFile()) return resolved;
-    } catch (error) {
-      if (error?.code !== 'ENOENT' && error?.code !== 'EACCES') throw error;
-    }
-  }
-  throw new TypeError(`RC1 v6 executableをPATHから解決できない: ${command}`);
-}
-
-/** 実行予定Codegraphのidentityと、そのdigestを再計算できる実bytesを同時captureする。 */
-export async function captureRc1V6CodegraphExecutable() {
-  const executablePath = await resolveExecutable('codegraph');
-  const executableBytes = await readFile(executablePath);
-  const { stdout } = await execFileAsync(executablePath, ['--version'], {
+/** Lattice内蔵sensorのidentityと、そのdigestを再計算できる実bytesを同時captureする。 */
+export async function captureRc1V6LatticeSensorExecutable() {
+  const executableBytes = await readFile(LATTICE_SENSOR_CLI);
+  const { stdout } = await execFileAsync(process.execPath, [LATTICE_SENSOR_CLI, '--version'], {
     encoding: 'utf8',
     maxBuffer: 64 * 1024,
     env: { ...process.env, NO_COLOR: '1' },
   });
   const version = stdout.trim();
   if (!VERSION.test(version)) {
-    throw new TypeError('RC1 v6 Codegraph versionがsemverでない');
+    throw new TypeError('RC1 v6 LatticeSensor versionがsemverでない');
   }
   return {
     identity: {
-      schema: 'lattice.rc1.codegraph_identity.v1',
+      schema: 'lattice.rc1.sensor_identity.v1',
       version,
-      executable_ref: 'codegraph',
+      executable_ref: 'lattice-sensor',
       executable_digest: sha256(executableBytes),
     },
     executable_bytes: executableBytes,
@@ -203,8 +185,8 @@ export async function captureRc1V6CodegraphExecutable() {
 }
 
 /** portable identityだけを必要とする既存caller向け入口。 */
-export async function resolveRc1V6CodegraphIdentity() {
-  return (await captureRc1V6CodegraphExecutable()).identity;
+export async function resolveRc1V6LatticeSensorIdentity() {
+  return (await captureRc1V6LatticeSensorExecutable()).identity;
 }
 
 /** v1 evidence bundleへsource／tool measurementを追加する。 */
@@ -214,7 +196,7 @@ export function bindRc1V6EvidenceBundle(options = {}) {
     'base_sha',
     'patch_digest',
     'snapshot',
-    'codegraph_identity',
+    'sensor_identity',
     'query_set_digest',
   ])
     || !validateRc1EvidenceBundle(options.bundle)
@@ -225,13 +207,13 @@ export function bindRc1V6EvidenceBundle(options = {}) {
     throw new TypeError('RC1 v6 evidence measurement inputが不正');
   }
   const measurement = {
-    schema: 'lattice.rc1.codegraph_measurement.v1',
+    schema: 'lattice.rc1.sensor_measurement.v1',
     base_sha: options.base_sha,
     patch_digest: options.patch_digest,
     snapshot: structuredClone(options.snapshot),
     snapshot_digest: digestArtifact(options.snapshot),
-    codegraph_identity: structuredClone(options.codegraph_identity),
-    codegraph_identity_digest: digestArtifact(options.codegraph_identity),
+    sensor_identity: structuredClone(options.sensor_identity),
+    sensor_identity_digest: digestArtifact(options.sensor_identity),
     query_set_digest: options.query_set_digest,
     raw_evidence_digest: options.bundle.raw.payload_digest,
   };
@@ -249,7 +231,7 @@ export function bindRc1V6EvidenceBundle(options = {}) {
       base_sha: options.base_sha,
       patch_digest: options.patch_digest,
       snapshot: options.snapshot,
-      codegraph_identity: options.codegraph_identity,
+      sensor_identity: options.sensor_identity,
       query_set_digest: options.query_set_digest,
     },
   });
@@ -281,7 +263,7 @@ function decodeRawEvidence(bundle) {
   try {
     return JSON.parse(Buffer.from(bundle.raw.payload_base64, 'base64').toString('utf8'));
   } catch {
-    throw new TypeError('RC1 v6 raw Codegraph evidenceをdecodeできない');
+    throw new TypeError('RC1 v6 raw LatticeSensor evidenceをdecodeできない');
   }
 }
 
@@ -317,14 +299,14 @@ export function compileRc1V6BoundaryCondition(options = {}) {
     candidateSpec: options.candidateSpec,
     manualEvidence: options.manualEvidence,
     querySet: options.querySet,
-    codegraphEvidence: decodeRawEvidence(options.bundle),
+    sensorEvidence: decodeRawEvidence(options.bundle),
     codeSnapshotDigest: options.bundle.measurement.snapshot_digest,
     planVersion: options.planVersion,
   });
   if (compiled.boundary_manifest.source.code_snapshot_digest
       !== options.bundle.measurement.snapshot_digest
-    || compiled.boundary_manifest.source.codegraph_version
-      !== options.bundle.measurement.codegraph_identity.version) {
+    || compiled.boundary_manifest.source.sensor_version
+      !== options.bundle.measurement.sensor_identity.version) {
     throw new TypeError('RC1 v6 compiler outputがmeasurement identityと一致しない');
   }
   return compiled;

package/src/rc2-artifact-set.mjs

@@ -57,10 +57,10 @@ const RC1_INPUT_PATHS = Object.freeze({
   oracle: 'inputs/rc1/behavior-oracle-v2.json',
 });
 
-const CODEGRAPH_CONFIG_PATH = 'identity/codegraph-config.json';
+const SENSOR_CONFIG_PATH = 'identity/lattice-sensor-config.json';
 // ratified config epochのallowlist。artifactのconfig bytesはこのいずれかと完全一致し、
 // かつidentity.jsonのproject_config_digestと自己整合でなければreject（第三のbytesはfail closed）。
-const CODEGRAPH_CONFIG_EPOCHS = Object.freeze([
+const SENSOR_CONFIG_EPOCHS = Object.freeze([
   // ADR 0040 epoch（RC2 v2〜v4 canonical artifactが保存する当時のratified config）
   Buffer.from('{"exclude":["research/campaigns/**/artifacts/**/identity/"]}\n', 'utf8'),
   // ADR 0044 Decision 10.3 epoch（research/runs/ event store除外、RC3-B以降のfresh実行）
@@ -68,11 +68,16 @@ const CODEGRAPH_CONFIG_EPOCHS = Object.freeze([
     '{"exclude":["research/campaigns/**/artifacts/**/identity/","research/runs/"]}\n',
     'utf8',
   ),
+  // ADR 0053 Decision 3 epoch（Lattice TODO state／generated artifact除外、G2以降のfresh実行）
+  Buffer.from(
+    '{"exclude":["research/campaigns/**/artifacts/**/identity/","research/runs/",".lattice/todo/",".lattice/generated/"]}\n',
+    'utf8',
+  ),
 ]);
 
 const V1_IDENTITY_PATHS = Object.freeze([
-  'identity/codegraph-adapter.mjs',
-  'identity/codegraph-executable',
+  'identity/lattice-sensor-adapter.mjs',
+  'identity/lattice-sensor-executable',
   'identity/rc1-black-box-oracle.mjs',
   'identity/rc1-boundary-compiler.mjs',
   'identity/rc1-evidence-bundle.mjs',
@@ -88,7 +93,7 @@ const V1_IDENTITY_PATHS = Object.freeze([
 
 const V2_IDENTITY_PATHS = Object.freeze([
   ...V1_IDENTITY_PATHS,
-  CODEGRAPH_CONFIG_PATH,
+  SENSOR_CONFIG_PATH,
 ]);
 
 const V3_IDENTITY_PATHS = V2_IDENTITY_PATHS;
@@ -133,7 +138,7 @@ const BYTE_PRESERVING_JSON_PATHS = new Set([
   'predecessors/rc1-v6-artifact-manifest.json',
   'predecessors/rc1-v6-transform-artifact.json',
   'predecessors/rc1-v6-transform-receipt.json',
-  CODEGRAPH_CONFIG_PATH,
+  SENSOR_CONFIG_PATH,
 ]);
 
 const TRANSFORM_PATHS = Object.freeze([
@@ -392,10 +397,10 @@ function verifyIdentity(context) {
   const identity = context.json.get('identity.json');
   const projectConfigBound = context.artifactVersion !== 'v1';
   const expectedIdentitySchema = `lattice.rc2.execution_identity.${context.artifactVersion}`;
-  const expectedCodegraphSchema = projectConfigBound
-    ? 'lattice.rc2.codegraph_identity.v2'
-    : 'lattice.rc2.codegraph_identity.v1';
-  const codegraphKeys = projectConfigBound
+  const expectedLatticeSensorSchema = projectConfigBound
+    ? 'lattice.rc2.sensor_identity.v2'
+    : 'lattice.rc2.sensor_identity.v1';
+  const sensorKeys = projectConfigBound
     ? [
       'schema',
       'version',
@@ -408,30 +413,30 @@ function verifyIdentity(context) {
   if (!exactRecord(identity, [
     'schema',
     'sources',
-    'codegraph_identity',
-    'codegraph_identity_digest',
+    'sensor_identity',
+    'sensor_identity_digest',
     'before_digest',
     'after_digest',
   ])
     || identity.schema !== expectedIdentitySchema
     || !Array.isArray(identity.sources)
     || identity.sources.length !== V1_IDENTITY_PATHS.length - 1
-    || !exactRecord(identity.codegraph_identity, codegraphKeys)
-    || identity.codegraph_identity.schema !== expectedCodegraphSchema
-    || !SHA256.test(identity.codegraph_identity.executable_digest)
-    || identity.codegraph_identity.executable_digest
-      !== sha256(context.payloads.get('identity/codegraph-executable'))
+    || !exactRecord(identity.sensor_identity, sensorKeys)
+    || identity.sensor_identity.schema !== expectedLatticeSensorSchema
+    || !SHA256.test(identity.sensor_identity.executable_digest)
+    || identity.sensor_identity.executable_digest
+      !== sha256(context.payloads.get('identity/lattice-sensor-executable'))
     || (projectConfigBound && (
-      identity.codegraph_identity.project_config_ref !== CODEGRAPH_CONFIG_PATH
-      || !SHA256.test(identity.codegraph_identity.project_config_digest)
-      || identity.codegraph_identity.project_config_digest
-        !== sha256(context.payloads.get(CODEGRAPH_CONFIG_PATH))
+      identity.sensor_identity.project_config_ref !== SENSOR_CONFIG_PATH
+      || !SHA256.test(identity.sensor_identity.project_config_digest)
+      || identity.sensor_identity.project_config_digest
+        !== sha256(context.payloads.get(SENSOR_CONFIG_PATH))
     ))
-    || identity.codegraph_identity_digest !== digestArtifact(identity.codegraph_identity)) {
+    || identity.sensor_identity_digest !== digestArtifact(identity.sensor_identity)) {
     return false;
   }
   const expectedSourceRefs = V1_IDENTITY_PATHS
-    .filter((relativePath) => relativePath !== 'identity/codegraph-executable');
+    .filter((relativePath) => relativePath !== 'identity/lattice-sensor-executable');
   const actualRefs = identity.sources.map(({ artifact_ref: ref }) => ref).sort();
   if (!sameArtifact(actualRefs, expectedSourceRefs)) return false;
   for (const source of identity.sources) {
@@ -448,20 +453,20 @@ function verifyIdentity(context) {
       artifact_ref: artifactRef,
       digest,
     })),
-    codegraph_identity: identity.codegraph_identity,
+    sensor_identity: identity.sensor_identity,
   };
   const digest = digestArtifact(snapshot);
   return identity.before_digest === digest && identity.after_digest === digest;
 }
 
-function verifyCodegraphConfig(context) {
+function verifyLatticeSensorConfig(context) {
   if (context.artifactVersion === 'v1') return false;
-  const bytes = context.payloads.get(CODEGRAPH_CONFIG_PATH);
+  const bytes = context.payloads.get(SENSOR_CONFIG_PATH);
   const identity = context.json.get('identity.json');
   return Buffer.isBuffer(bytes)
-    && CODEGRAPH_CONFIG_EPOCHS.some((epochBytes) => bytes.equals(epochBytes))
-    && identity?.codegraph_identity?.project_config_ref === CODEGRAPH_CONFIG_PATH
-    && identity.codegraph_identity.project_config_digest === sha256(bytes);
+    && SENSOR_CONFIG_EPOCHS.some((epochBytes) => bytes.equals(epochBytes))
+    && identity?.sensor_identity?.project_config_ref === SENSOR_CONFIG_PATH
+    && identity.sensor_identity.project_config_digest === sha256(bytes);
 }
 
 function verifySurfaceSnapshot(snapshot, expectedPaths, expectedPresentPaths) {
@@ -812,8 +817,8 @@ function rehydrateStoredEvidence(evidence) {
     'payload_digest',
     'payload_base64_chunks',
   ])
-    || raw.schema !== 'lattice.rc2.chunked_codegraph_raw_receipt.v1'
-    || raw.source_schema !== 'lattice.codegraph_raw_opaque_receipt.v1'
+    || raw.schema !== 'lattice.rc2.chunked_sensor_raw_receipt.v1'
+    || raw.source_schema !== 'lattice.sensor_raw_opaque_receipt.v1'
     || raw.source_encoding !== 'canonical-json-base64'
     || raw.storage_encoding !== 'ordered-base64-chunks'
     || !Number.isSafeInteger(raw.canonical_bytes)
@@ -890,7 +895,7 @@ function verifyRuns(context) {
       ? null
       : (family === 'primary' ? accepted?.patch?.digest : rc1Transform?.patch?.digest);
     if (!plainRecord(run)
-      || run.schema !== 'lattice.rc2.fresh_codegraph_run.v1'
+      || run.schema !== 'lattice.rc2.fresh_sensor_run.v1'
       || run.run_id !== runId
       || run.family !== family
       || run.condition !== condition
@@ -901,12 +906,12 @@ function verifyRuns(context) {
       || run.evidence.run_id !== runId
       || run.evidence.condition !== condition
       || run.evidence.query_set_digest !== digestArtifact(inputs.querySet)
-      || run.measurement?.schema !== 'lattice.rc2.codegraph_measurement.v1'
+      || run.measurement?.schema !== 'lattice.rc2.sensor_measurement.v1'
       || run.measurement.base_sha !== context.manifest.base_sha
       || run.measurement.patch_digest !== expectedPatch
       || run.measurement.snapshot_digest !== digestArtifact(run.measurement.snapshot)
-      || run.measurement.codegraph_identity_digest !== identity.codegraph_identity_digest
-      || !sameArtifact(run.measurement.codegraph_identity, identity.codegraph_identity)
+      || run.measurement.sensor_identity_digest !== identity.sensor_identity_digest
+      || !sameArtifact(run.measurement.sensor_identity, identity.sensor_identity)
       || run.measurement.query_set_digest !== digestArtifact(inputs.querySet)
       || run.measurement.raw_evidence_digest !== run.evidence.raw.payload_digest
       || run.source_invariant?.outcome !== 'passed'
@@ -952,7 +957,7 @@ function compilePrimaryRecord({ run, inputs, manualEvidence, planInput, conditio
     manualEvidence,
     querySet: inputs.querySet,
     sourceSnapshot: run.measurement.snapshot,
-    codegraphEvidence: run.evidence.portable,
+    sensorEvidence: run.evidence.portable,
   });
   return compiledRecord({
     condition,
@@ -969,7 +974,7 @@ function compileUnknownRecord({ run, inputs }) {
     manualEvidence: inputs.unknownManualEvidence,
     querySet: inputs.querySet,
     sourceSnapshot: run.measurement.snapshot,
-    codegraphEvidence: run.evidence.portable,
+    sensorEvidence: run.evidence.portable,
   });
   const outcome = compileSchedulabilityGraphV2(bundle.graph);
   const verification = verifySchedulabilityPlanV2(bundle.graph, {
@@ -995,7 +1000,7 @@ function recompileLegacy(run, inputs, manualEvidence, label) {
     candidateSpec: inputs.candidateSpec,
     manualEvidence,
     querySet: inputs.querySet,
-    codegraphEvidence: rawEvidence,
+    sensorEvidence: rawEvidence,
     codeSnapshotDigest: run.measurement.snapshot_digest,
     planVersion: `rc2-${run.condition}-transfer-${label}`,
   });
@@ -1264,7 +1269,7 @@ function expectedPredecessorKinds(context) {
   expected.set('identity/schedulability-compiler-v2.mjs', 'compiler_identity');
   expected.set('identity/schedulability-verifier-v2.mjs', 'verifier_identity');
   if (context.artifactVersion !== 'v1') {
-    expected.set(CODEGRAPH_CONFIG_PATH, 'codegraph_project_config');
+    expected.set(SENSOR_CONFIG_PATH, 'sensor_project_config');
   }
   return expected;
 }
@@ -1520,7 +1525,7 @@ export function verifyRc2CampaignArtifactSet(options = {}) {
 
   check('identity_binding', verifyIdentity(context));
   if (context.artifactVersion !== 'v1') {
-    check('codegraph_config_binding', verifyCodegraphConfig(context));
+    check('sensor_config_binding', verifyLatticeSensorConfig(context));
   }
   check('transform_binding', verifyTransform(context));
   check('fresh_run_binding', verifyRuns(context));

package/src/rc2-campaign.mjs

@@ -1,8 +1,6 @@
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { constants as fsConstants } from 'node:fs';
 import {
-  access,
   lstat,
   mkdir,
   mkdtemp,
@@ -22,7 +20,8 @@ import {
   digestArtifact,
 } from './artifact-contracts.mjs';
 import { compileBoundaryCondition } from './boundary-compiler.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
+import { invokeSensorCli, LATTICE_SENSOR_CLI } from './sensor-runtime.mjs';
 import { runIsolatedTransform } from './isolation-runner.mjs';
 import { runRc1BlackBoxOracle } from './rc1-black-box-oracle.mjs';
 import { createRc1EvidenceBundle } from './rc1-evidence-bundle.mjs';
@@ -48,16 +47,16 @@ const ARTIFACT_ROOTS = Object.freeze({
   v3: 'research/campaigns/rc2/artifacts/v3',
   v4: 'research/campaigns/rc2/artifacts/v4',
 });
-const CODEGRAPH_CONFIG_REPO_PATH = 'codegraph.json';
-const CODEGRAPH_CONFIG_ARTIFACT_PATH = 'identity/codegraph-config.json';
-// live実行は現在ratifiedなconfig（ADR 0044 Decision 10.3 epoch）との完全一致だけを受理する。
+const SENSOR_CONFIG_REPO_PATH = 'lattice-sensor.json';
+const SENSOR_CONFIG_ARTIFACT_PATH = 'identity/lattice-sensor-config.json';
+// live実行は現在ratifiedなconfig（ADR 0053 Decision 3 epoch）との完全一致だけを受理する。
 // 過去epochのartifact検証はrc2-artifact-set.mjsのratified epoch allowlistが担う。
-const CODEGRAPH_CONFIG_BYTES = Buffer.from(
-  '{"exclude":["research/campaigns/**/artifacts/**/identity/","research/runs/"]}\n',
+const SENSOR_CONFIG_BYTES = Buffer.from(
+  '{"exclude":["research/campaigns/**/artifacts/**/identity/","research/runs/",".lattice/todo/",".lattice/generated/"]}\n',
   'utf8',
 );
 const V2_ONLY_ARTIFACT_PATHS = Object.freeze([
-  CODEGRAPH_CONFIG_ARTIFACT_PATH,
+  SENSOR_CONFIG_ARTIFACT_PATH,
   'predecessors/adr-0040.md',
   'predecessors/rc2-v1-artifact-manifest.json',
   'predecessors/rc2-v1-new-plan-version.json',
@@ -125,7 +124,7 @@ const RC1_ARTIFACT_INPUTS = Object.freeze({
 });
 
 const SOURCE_IDENTITIES = Object.freeze([
-  ['src/codegraph-adapter.mjs', 'identity/codegraph-adapter.mjs', new URL('./codegraph-adapter.mjs', import.meta.url)],
+  ['src/sensor-adapter.mjs', 'identity/lattice-sensor-adapter.mjs', new URL('./sensor-adapter.mjs', import.meta.url)],
   ['src/rc1-black-box-oracle.mjs', 'identity/rc1-black-box-oracle.mjs', new URL('./rc1-black-box-oracle.mjs', import.meta.url)],
   ['src/boundary-compiler.mjs', 'identity/rc1-boundary-compiler.mjs', new URL('./boundary-compiler.mjs', import.meta.url)],
   ['src/rc1-evidence-bundle.mjs', 'identity/rc1-evidence-bundle.mjs', new URL('./rc1-evidence-bundle.mjs', import.meta.url)],
@@ -149,7 +148,7 @@ const PREDECESSOR_FILES = Object.freeze({
   'predecessors/rc1-v6-seam.patch': `${RC1_ARTIFACT_ROOT}/transform/seam.patch`,
   'predecessors/rc1-v6-transform-artifact.json': `${RC1_ARTIFACT_ROOT}/transform/transform-artifact.json`,
   'predecessors/rc1-v6-transform-receipt.json': `${RC1_ARTIFACT_ROOT}/transform/transform-receipt.json`,
-  'predecessors/adr-0040.md': 'docs/adr/0040-rc2-post-publication-codegraph-scope-and-artifact-v2.md',
+  'predecessors/adr-0040.md': 'docs/adr/0040-rc2-post-publication-lattice-sensor-scope-and-artifact-v2.md',
   'predecessors/rc2-v1-artifact-manifest.json': `${ARTIFACT_ROOTS.v1}/artifact-manifest.json`,
   'predecessors/rc2-v1-new-plan-version.json': `${ARTIFACT_ROOTS.v1}/new-plan-version.json`,
   'predecessors/adr-0041.md': 'docs/adr/0041-rc2-artifact-semantic-oracle-mutation-binding.md',
@@ -228,22 +227,6 @@ function run(command, args, { cwd, input, allowExitCodes = [0] } = {}) {
   });
 }
 
-async function resolveExecutable(command) {
-  const entries = String(process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
-  for (const directory of entries) {
-    const candidate = path.join(directory, command);
-    try {
-      await access(candidate, fsConstants.X_OK);
-      const resolved = await realpath(candidate);
-      const stat = await lstat(resolved);
-      if (stat.isFile()) return resolved;
-    } catch (error) {
-      if (error?.code !== 'ENOENT' && error?.code !== 'EACCES') throw error;
-    }
-  }
-  throw new TypeError(`${command} executableをPATHから解決できない`);
-}
-
 async function captureExecutionIdentity(repoRoot) {
   const sources = [];
   const payloads = new Map();
@@ -252,25 +235,24 @@ async function captureExecutionIdentity(repoRoot) {
     payloads.set(artifactRef, bytes);
     sources.push({ runtime_path: runtimePath, artifact_ref: artifactRef, digest: sha256(bytes) });
   }
-  const executablePath = await resolveExecutable('codegraph');
-  const executableBytes = await readFile(executablePath);
-  const version = (await run(executablePath, ['--version'])).stdout.toString('utf8').trim();
-  if (!SEMVER.test(version)) throw new TypeError('Codegraph versionがsemverではない');
-  const projectConfigBytes = await readFile(path.join(repoRoot, CODEGRAPH_CONFIG_REPO_PATH));
-  if (!projectConfigBytes.equals(CODEGRAPH_CONFIG_BYTES)) {
-    throw new TypeError('Codegraph project config bytesがRC2 v2 contractと一致しない');
+  const executableBytes = await readFile(LATTICE_SENSOR_CLI);
+  const version = (await run(process.execPath, [LATTICE_SENSOR_CLI, '--version'])).stdout.toString('utf8').trim();
+  if (!SEMVER.test(version)) throw new TypeError('LatticeSensor versionがsemverではない');
+  const projectConfigBytes = await readFile(path.join(repoRoot, SENSOR_CONFIG_REPO_PATH));
+  if (!projectConfigBytes.equals(SENSOR_CONFIG_BYTES)) {
+    throw new TypeError('LatticeSensor project config bytesがRC2 v2 contractと一致しない');
   }
-  const codegraphIdentity = {
-    schema: 'lattice.rc2.codegraph_identity.v2',
+  const sensorIdentity = {
+    schema: 'lattice.rc2.sensor_identity.v2',
     version,
-    executable_ref: 'codegraph',
+    executable_ref: 'lattice-sensor',
     executable_digest: sha256(executableBytes),
-    project_config_ref: CODEGRAPH_CONFIG_ARTIFACT_PATH,
+    project_config_ref: SENSOR_CONFIG_ARTIFACT_PATH,
     project_config_digest: sha256(projectConfigBytes),
   };
-  payloads.set('identity/codegraph-executable', executableBytes);
-  payloads.set(CODEGRAPH_CONFIG_ARTIFACT_PATH, projectConfigBytes);
-  const snapshot = { sources, codegraph_identity: codegraphIdentity };
+  payloads.set('identity/lattice-sensor-executable', executableBytes);
+  payloads.set(SENSOR_CONFIG_ARTIFACT_PATH, projectConfigBytes);
+  const snapshot = { sources, sensor_identity: sensorIdentity };
   return { snapshot, digest: digestArtifact(snapshot), payloads };
 }
 
@@ -385,21 +367,21 @@ async function applyPatch(worktreePath, patch) {
   await run('git', ['apply', '--binary', '-'], { cwd: worktreePath, input: patch });
 }
 
-async function captureCodegraphBootstrap(worktreePath) {
+async function captureLatticeSensorBootstrap(worktreePath) {
   try {
-    return await readFile(path.join(worktreePath, '.codegraph', '.gitignore'));
+    return await readFile(path.join(worktreePath, '.lattice/sensor', '.gitignore'));
   } catch (error) {
     if (error?.code === 'ENOENT') return null;
     throw error;
   }
 }
 
-async function restoreCodegraphBootstrap(worktreePath, bootstrap) {
-  const codegraphPath = path.join(worktreePath, '.codegraph');
-  await rm(codegraphPath, { recursive: true, force: true });
+async function restoreLatticeSensorBootstrap(worktreePath, bootstrap) {
+  const sensorPath = path.join(worktreePath, '.lattice/sensor');
+  await rm(sensorPath, { recursive: true, force: true });
   if (bootstrap === null) return;
-  await mkdir(codegraphPath, { recursive: true });
-  await writeFile(path.join(codegraphPath, '.gitignore'), bootstrap);
+  await mkdir(sensorPath, { recursive: true });
+  await writeFile(path.join(sensorPath, '.gitignore'), bootstrap);
 }
 
 async function worktreeCount(repoRoot) {
@@ -422,7 +404,7 @@ async function observeFreshIndex({
   paths,
   patch,
   allowedPaths,
-  codegraphIdentity,
+  sensorIdentity,
   oracle,
   rc1Inputs,
   costMeasurements,
@@ -452,16 +434,16 @@ async function observeFreshIndex({
         : await runRc1BlackBoxOracle({ repoRoot: worktreePath, oracle });
       oracleElapsedMs = roundedMilliseconds(oracleStarted);
       if (oracleReceipt.outcome !== 'passed') throw new TypeError(`${runId} oracle failed`);
-      const bootstrap = await captureCodegraphBootstrap(worktreePath);
+      const bootstrap = await captureLatticeSensorBootstrap(worktreePath);
       try {
         const indexStarted = performance.now();
-        await run('codegraph', ['init', '.'], { cwd: worktreePath });
+        await invokeSensorCli(run, ['init', '.'], { cwd: worktreePath });
         indexElapsedMs = roundedMilliseconds(indexStarted);
         const queryStarted = performance.now();
-        rawEvidence = await collectCodegraphEvidence({ cwd: worktreePath, querySet });
+        rawEvidence = await collectSensorEvidence({ cwd: worktreePath, querySet });
         queryElapsedMs = roundedMilliseconds(queryStarted);
       } finally {
-        await restoreCodegraphBootstrap(worktreePath, bootstrap);
+        await restoreLatticeSensorBootstrap(worktreePath, bootstrap);
       }
     },
   });
@@ -480,13 +462,13 @@ async function observeFreshIndex({
   const evidence = createRc1EvidenceBundle({ condition, runId, querySet, rawEvidence });
   const patchDigest = condition === 'treatment' ? sha256(isolated.patch) : null;
   const measurement = {
-    schema: 'lattice.rc2.codegraph_measurement.v1',
+    schema: 'lattice.rc2.sensor_measurement.v1',
     base_sha: baseSha,
     patch_digest: patchDigest,
     snapshot,
     snapshot_digest: digestArtifact(snapshot),
-    codegraph_identity: structuredClone(codegraphIdentity),
-    codegraph_identity_digest: digestArtifact(codegraphIdentity),
+    sensor_identity: structuredClone(sensorIdentity),
+    sensor_identity_digest: digestArtifact(sensorIdentity),
     query_set_digest: digestArtifact(querySet),
     raw_evidence_digest: evidence.raw.payload_digest,
   };
@@ -503,7 +485,7 @@ async function observeFreshIndex({
     });
   }
   const runRecord = {
-    schema: 'lattice.rc2.fresh_codegraph_run.v1',
+    schema: 'lattice.rc2.fresh_sensor_run.v1',
     family,
     condition,
     run_id: runId,
@@ -529,7 +511,7 @@ async function observeFreshIndex({
       candidateSpec: rc1Inputs.candidateSpec,
       manualEvidence,
       querySet: rc1Inputs.querySet,
-      codegraphEvidence: raw,
+      sensorEvidence: raw,
       codeSnapshotDigest: measurement.snapshot_digest,
       planVersion: `rc2-${condition}-transfer-${label}`,
     });
@@ -585,7 +567,7 @@ function compilePrimary({ runRecord, inputs, manualEvidence, planInput, conditio
       manualEvidence,
       querySet: inputs.querySet,
       sourceSnapshot: runRecord.measurement.snapshot,
-      codegraphEvidence: runRecord.evidence.portable,
+      sensorEvidence: runRecord.evidence.portable,
     })
   ));
   return compiledRecord({ condition, runId: runRecord.run_id, bundle, costMeasurements });
@@ -600,7 +582,7 @@ function compileUnknown({ runRecord, inputs, costMeasurements }) {
       manualEvidence: inputs.unknownManualEvidence,
       querySet: inputs.querySet,
       sourceSnapshot: runRecord.measurement.snapshot,
-      codegraphEvidence: runRecord.evidence.portable,
+      sensorEvidence: runRecord.evidence.portable,
     })
   ));
   const outcome = timedSync(`compile.${condition}.${runRecord.run_id}`, costMeasurements, () => (
@@ -796,7 +778,7 @@ function storedEvidence(evidence) {
     'payload_digest',
     'payload_base64',
   ])
-    || raw.schema !== 'lattice.codegraph_raw_opaque_receipt.v1'
+    || raw.schema !== 'lattice.sensor_raw_opaque_receipt.v1'
     || raw.encoding !== 'canonical-json-base64'
     || typeof raw.payload_base64 !== 'string') {
     throw new TypeError('run raw evidence receipt is invalid');
@@ -824,7 +806,7 @@ function storedEvidence(evidence) {
   return {
     ...structuredClone(evidence),
     raw: {
-      schema: 'lattice.rc2.chunked_codegraph_raw_receipt.v1',
+      schema: 'lattice.rc2.chunked_sensor_raw_receipt.v1',
       source_schema: raw.schema,
       media_type: raw.media_type,
       source_encoding: raw.encoding,
@@ -881,7 +863,7 @@ function predecessorDescriptors(payloads) {
   add('execution_identity', 'identity.json');
   add('compiler_identity', 'identity/schedulability-compiler-v2.mjs');
   add('verifier_identity', 'identity/schedulability-verifier-v2.mjs');
-  add('codegraph_project_config', CODEGRAPH_CONFIG_ARTIFACT_PATH);
+  add('sensor_project_config', SENSOR_CONFIG_ARTIFACT_PATH);
   return descriptors;
 }
 
@@ -1204,7 +1186,7 @@ export async function runRc2Campaign(options = {}) {
   const common = {
     repoRoot: root,
     baseSha,
-    codegraphIdentity: identityBefore.snapshot.codegraph_identity,
+    sensorIdentity: identityBefore.snapshot.sensor_identity,
     costMeasurements,
   };
   const primaryControl = [];
@@ -1278,8 +1260,8 @@ export async function runRc2Campaign(options = {}) {
   const identity = {
     schema: 'lattice.rc2.execution_identity.v4',
     sources: identityBefore.snapshot.sources,
-    codegraph_identity: identityBefore.snapshot.codegraph_identity,
-    codegraph_identity_digest: digestArtifact(identityBefore.snapshot.codegraph_identity),
+    sensor_identity: identityBefore.snapshot.sensor_identity,
+    sensor_identity_digest: digestArtifact(identityBefore.snapshot.sensor_identity),
     before_digest: identityBefore.digest,
     after_digest: identityAfter.digest,
   };