@quolu/lattice 0.1.0 → 0.12.2

package/src/rc1-evidence-bundle.mjs

@@ -4,14 +4,14 @@ import {
   canonicalizeArtifact,
   digestArtifact,
 } from './artifact-contracts.mjs';
-import { portableCodegraphOutcome } from './codegraph-adapter.mjs';
+import { portableSensorOutcome } from './sensor-adapter.mjs';
 
 const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
 const SHA256 = /^[0-9a-f]{64}$/;
 const CONDITIONS = new Set(['control', 'treatment']);
 const OPERATIONS = new Set(['status', 'query', 'callers', 'callees', 'impact', 'affected']);
-const PROJECTION = 'lattice.codegraph_portable_outcome.v1';
-const SANITIZER = 'lattice.codegraph_diagnostic_sanitizer.v1';
+const PROJECTION = 'lattice.sensor_portable_outcome.v1';
+const SANITIZER = 'lattice.sensor_diagnostic_sanitizer.v1';
 const STATUS_REMOVALS = Object.freeze([
   'projectPath',
   'indexPath',
@@ -69,7 +69,7 @@ function sameArtifact(left, right) {
 
 function validateQuerySet(querySet) {
   if (!exactRecord(querySet, ['schema', 'queries'])
-    || querySet.schema !== 'lattice.codegraph_query_set.v2'
+    || querySet.schema !== 'lattice.sensor_query_set.v2'
     || !Array.isArray(querySet.queries)
     || querySet.queries.length === 0
     || querySet.queries.length > 256) {
@@ -194,8 +194,8 @@ function rawReceipt(rawEvidence) {
   const canonical = canonicalizeArtifact(rawEvidence);
   const bytes = Buffer.from(canonical, 'utf8');
   return {
-    schema: 'lattice.codegraph_raw_opaque_receipt.v1',
-    media_type: 'application/vnd.lattice.codegraph-evidence+json',
+    schema: 'lattice.sensor_raw_opaque_receipt.v1',
+    media_type: 'application/vnd.lattice.sensor-evidence+json',
     encoding: 'canonical-json-base64',
     payload_base64: bytes.toString('base64'),
     payload_digest: sha256(bytes),
@@ -207,13 +207,13 @@ function diagnosticArtifact(rawEvidence, sourceRawDigest) {
   const { payload, operations } = sanitizeDiagnostic(rawEvidence);
   if (containsAbsolutePath(payload)) fail('sanitized diagnosticに絶対pathが残る');
   const manifest = {
-    schema: 'lattice.codegraph_sanitization_manifest.v1',
+    schema: 'lattice.sensor_sanitization_manifest.v1',
     sanitizer: SANITIZER,
     rules_digest: digestArtifact(SANITIZATION_RULES),
     operations,
   };
   return {
-    schema: 'lattice.codegraph_sanitized_diagnostic.v1',
+    schema: 'lattice.sensor_sanitized_diagnostic.v1',
     source_raw_digest: sourceRawDigest,
     sanitization_manifest: manifest,
     sanitization_manifest_digest: digestArtifact(manifest),
@@ -224,7 +224,7 @@ function diagnosticArtifact(rawEvidence, sourceRawDigest) {
 
 function buildPortable(querySet, rawEvidence) {
   const querySetDigest = digestArtifact(querySet);
-  const outcomes = rawEvidence.outcomes.map((outcome) => portableCodegraphOutcome(outcome));
+  const outcomes = rawEvidence.outcomes.map((outcome) => portableSensorOutcome(outcome));
   if (containsAbsolutePath(outcomes)) fail('portable outcomeに絶対pathが残る');
   const perQuery = outcomes.map((outcome, index) => ({
     id: querySet.queries[index].id,
@@ -233,7 +233,7 @@ function buildPortable(querySet, rawEvidence) {
     result_digest: digestArtifact(outcome),
   }));
   const portable = {
-    schema: 'lattice.codegraph_portable_preimage.v1',
+    schema: 'lattice.sensor_portable_preimage.v1',
     projection: PROJECTION,
     query_set_digest: querySetDigest,
     outcomes,
@@ -247,7 +247,7 @@ function buildPortable(querySet, rawEvidence) {
 /** full portable payloadだけからaggregate digestを再計算する。 */
 export function recomputePortableAggregate(portable) {
   if (!isPlainObject(portable)
-    || portable.schema !== 'lattice.codegraph_portable_preimage.v1'
+    || portable.schema !== 'lattice.sensor_portable_preimage.v1'
     || portable.projection !== PROJECTION
     || typeof portable.query_set_digest !== 'string'
     || !SHA256.test(portable.query_set_digest)
@@ -270,8 +270,8 @@ function decodeRawReceipt(receipt) {
     'payload_digest',
     'canonical_bytes',
   ])
-    || receipt.schema !== 'lattice.codegraph_raw_opaque_receipt.v1'
-    || receipt.media_type !== 'application/vnd.lattice.codegraph-evidence+json'
+    || receipt.schema !== 'lattice.sensor_raw_opaque_receipt.v1'
+    || receipt.media_type !== 'application/vnd.lattice.sensor-evidence+json'
     || receipt.encoding !== 'canonical-json-base64'
     || typeof receipt.payload_base64 !== 'string'
     || typeof receipt.payload_digest !== 'string'
@@ -302,7 +302,7 @@ function validatePortable(portable, querySet, rawEvidence) {
     'per_query',
     'aggregate_digest',
   ])
-    || portable.schema !== 'lattice.codegraph_portable_preimage.v1'
+    || portable.schema !== 'lattice.sensor_portable_preimage.v1'
     || portable.projection !== PROJECTION
     || portable.query_set_digest !== digestArtifact(querySet)
     || !Array.isArray(portable.outcomes)
@@ -337,7 +337,7 @@ function validateDiagnostic(diagnostic, rawEvidence, rawDigest) {
     'payload',
     'payload_digest',
   ])
-    || diagnostic.schema !== 'lattice.codegraph_sanitized_diagnostic.v1'
+    || diagnostic.schema !== 'lattice.sensor_sanitized_diagnostic.v1'
     || diagnostic.source_raw_digest !== rawDigest
     || diagnostic.sanitization_manifest_digest
       !== digestArtifact(diagnostic.sanitization_manifest)
@@ -349,7 +349,7 @@ function validateDiagnostic(diagnostic, rawEvidence, rawDigest) {
 }
 
 /**
- * 1 fresh Codegraph runをraw／diagnostic／portableの独立componentへcompileする。
+ * 1 fresh LatticeSensor runをraw／diagnostic／portableの独立componentへcompileする。
  */
 export function createRc1EvidenceBundle({
   condition,

package/src/rc1-v4-campaign.mjs

@@ -20,7 +20,8 @@ import {
   compileBoundaryCondition,
   RC1_BOUNDARY_COMPILER_CONTRACT,
 } from './boundary-compiler.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
+import { invokeSensorCli } from './sensor-runtime.mjs';
 import { runIsolatedTransform } from './isolation-runner.mjs';
 import { evaluateRc1Hypothesis } from './rc1-comparison.mjs';
 import {
@@ -145,21 +146,21 @@ async function applyAcceptedPatch(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 observeFreshIndex({
@@ -181,16 +182,16 @@ async function observeFreshIndex({
     transform: async ({ worktreePath }) => {
       if (condition === 'treatment') await applyAcceptedPatch(worktreePath, patch);
       snapshot = await fixedSnapshot(worktreePath);
-      const codegraphBootstrap = await captureCodegraphBootstrap(worktreePath);
+      const sensorBootstrap = await captureLatticeSensorBootstrap(worktreePath);
       try {
         const indexStartedAt = performance.now();
-        await run('codegraph', ['init', '.'], { cwd: worktreePath });
+        await invokeSensorCli(run, ['init', '.'], { cwd: worktreePath });
         indexElapsedMs = roundedMilliseconds(indexStartedAt);
         const queryStartedAt = performance.now();
-        rawEvidence = await collectCodegraphEvidence({ cwd: worktreePath, querySet });
+        rawEvidence = await collectSensorEvidence({ cwd: worktreePath, querySet });
         queryElapsedMs = roundedMilliseconds(queryStartedAt);
       } finally {
-        await restoreCodegraphBootstrap(worktreePath, codegraphBootstrap);
+        await restoreLatticeSensorBootstrap(worktreePath, sensorBootstrap);
       }
     },
     verifyCommands: [],
@@ -223,7 +224,7 @@ function compileOne({ inputs, observation, manualEvidence, planVersion }) {
     candidateSpec: inputs.candidateSpec,
     manualEvidence,
     querySet: inputs.querySet,
-    codegraphEvidence: observation.rawEvidence,
+    sensorEvidence: observation.rawEvidence,
     codeSnapshotDigest: observation.codeSnapshotDigest,
     planVersion,
   });
@@ -310,7 +311,7 @@ function evidenceSummary(bundles, querySet) {
       validateRc1EvidenceBundle(bundle)
         && bundle.diagnostic.payload.cwd === '<repo-root>'
         && bundle.diagnostic.sanitization_manifest.schema
-          === 'lattice.codegraph_sanitization_manifest.v1'
+          === 'lattice.sensor_sanitization_manifest.v1'
     )),
   };
 }

package/src/rc1-v5-artifact-set.mjs

@@ -313,7 +313,7 @@ function compilerReplayValid(context) {
           ? inputs.normalManualEvidence
           : inputs.negativeManualEvidence,
         querySet: inputs.querySet,
-        codegraphEvidence: rawEvidence,
+        sensorEvidence: rawEvidence,
         codeSnapshotDigest: run.code_snapshot_digest,
         planVersion: `rc1-v5-${condition}${variant === 'negative' ? '-negative' : ''}`,
       });
@@ -521,7 +521,7 @@ function evidenceSummary(bundles, querySet) {
       validateRc1EvidenceBundle(bundle)
         && bundle.diagnostic.payload.cwd === '<repo-root>'
         && bundle.diagnostic.sanitization_manifest.schema
-          === 'lattice.codegraph_sanitization_manifest.v1'
+          === 'lattice.sensor_sanitization_manifest.v1'
     )),
   };
 }

package/src/rc1-v5-campaign.mjs

@@ -20,7 +20,8 @@ import {
   compileBoundaryCondition,
   RC1_BOUNDARY_COMPILER_CONTRACT,
 } from './boundary-compiler.mjs';
-import { collectCodegraphEvidence } from './codegraph-adapter.mjs';
+import { collectSensorEvidence } from './sensor-adapter.mjs';
+import { invokeSensorCli } from './sensor-runtime.mjs';
 import { runIsolatedTransform } from './isolation-runner.mjs';
 import {
   createRc1EvidenceBundle,
@@ -150,21 +151,21 @@ async function applyAcceptedPatch(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 observeFreshIndex({
@@ -186,16 +187,16 @@ async function observeFreshIndex({
     transform: async ({ worktreePath }) => {
       if (condition === 'treatment') await applyAcceptedPatch(worktreePath, patch);
       snapshot = await fixedSnapshot(worktreePath);
-      const codegraphBootstrap = await captureCodegraphBootstrap(worktreePath);
+      const sensorBootstrap = await captureLatticeSensorBootstrap(worktreePath);
       try {
         const indexStartedAt = performance.now();
-        await run('codegraph', ['init', '.'], { cwd: worktreePath });
+        await invokeSensorCli(run, ['init', '.'], { cwd: worktreePath });
         indexElapsedMs = roundedMilliseconds(indexStartedAt);
         const queryStartedAt = performance.now();
-        rawEvidence = await collectCodegraphEvidence({ cwd: worktreePath, querySet });
+        rawEvidence = await collectSensorEvidence({ cwd: worktreePath, querySet });
         queryElapsedMs = roundedMilliseconds(queryStartedAt);
       } finally {
-        await restoreCodegraphBootstrap(worktreePath, codegraphBootstrap);
+        await restoreLatticeSensorBootstrap(worktreePath, sensorBootstrap);
       }
     },
     verifyCommands: [],
@@ -228,7 +229,7 @@ function compileOne({ inputs, observation, manualEvidence, planVersion }) {
     candidateSpec: inputs.candidateSpec,
     manualEvidence,
     querySet: inputs.querySet,
-    codegraphEvidence: observation.rawEvidence,
+    sensorEvidence: observation.rawEvidence,
     codeSnapshotDigest: observation.codeSnapshotDigest,
     planVersion,
   });
@@ -314,7 +315,7 @@ function evidenceSummary(bundles, querySet) {
       validateRc1EvidenceBundle(bundle)
         && bundle.diagnostic.payload.cwd === '<repo-root>'
         && bundle.diagnostic.sanitization_manifest.schema
-          === 'lattice.codegraph_sanitization_manifest.v1'
+          === 'lattice.sensor_sanitization_manifest.v1'
     )),
   };
 }

package/src/rc1-v6-artifact-set.mjs

@@ -35,13 +35,13 @@ const INPUT_PATHS = Object.freeze({
   querySet: 'inputs/query-set-v2.json',
   oracle: 'inputs/behavior-oracle-v2.json',
   runtimeIdentity: 'inputs/oracle-runtime-identity.json',
-  codegraphIdentity: 'inputs/codegraph-identity.json',
+  sensorIdentity: 'inputs/lattice-sensor-identity.json',
 });
 const RUN_IDS = Object.freeze(['control-1', 'control-2', 'treatment-1', 'treatment-2']);
 const IDENTITY_PATHS = Object.freeze({
   compiler: 'identity/boundary-compiler.mjs',
   oracleExecutor: 'identity/black-box-oracle.mjs',
-  codegraphExecutable: 'identity/codegraph-executable',
+  sensorExecutable: 'identity/lattice-sensor-executable',
 });
 const INVALIDATED_CONTEXTS = Object.freeze([
   {
@@ -123,7 +123,7 @@ function compilationSummary(compiled) {
   };
 }
 
-function fixedInputIdentity(inputs, runtimeIdentity, codegraphIdentity) {
+function fixedInputIdentity(inputs, runtimeIdentity, sensorIdentity) {
   return {
     plan_input: digestArtifact(inputs.planInput),
     candidate_spec: digestArtifact(inputs.candidateSpec),
@@ -132,7 +132,7 @@ function fixedInputIdentity(inputs, runtimeIdentity, codegraphIdentity) {
     query_set: digestArtifact(inputs.querySet),
     behavior_oracle: digestArtifact(inputs.oracle),
     oracle_runtime: digestArtifact(runtimeIdentity),
-    codegraph_identity: digestArtifact(codegraphIdentity),
+    sensor_identity: digestArtifact(sensorIdentity),
     capacity_writers: inputs.planInput.capacity.writers,
   };
 }
@@ -230,7 +230,7 @@ export function compileRc1V6Comparison({
   baseSha,
   inputs,
   runtimeIdentity,
-  codegraphIdentity,
+  sensorIdentity,
   compilerSourceDigest,
   control,
   treatment,
@@ -244,7 +244,7 @@ export function compileRc1V6Comparison({
   return {
     schema: 'lattice.rc1.control_treatment_comparison.v4',
     base_sha: baseSha,
-    fixed_inputs: fixedInputIdentity(inputs, runtimeIdentity, codegraphIdentity),
+    fixed_inputs: fixedInputIdentity(inputs, runtimeIdentity, sensorIdentity),
     independent_variable: {
       kind: 'accepted_production_and_test_seam',
       transform_artifact_digest: transform.artifact_digest,
@@ -256,7 +256,7 @@ export function compileRc1V6Comparison({
       source_digest: compilerSourceDigest,
       condition_selector: RC1_BOUNDARY_COMPILER_CONTRACT.condition_selector,
     },
-    codegraph_identity: structuredClone(codegraphIdentity),
+    sensor_identity: structuredClone(sensorIdentity),
     oracle_runtime_identity: structuredClone(runtimeIdentity),
     conditions: {
       control: compiledConditionSummary(control, controlBundles),
@@ -283,8 +283,8 @@ export function evaluateRc1V6Hypothesis(comparison) {
         && SHA256.test(comparison?.compiler?.source_digest),
     },
     {
-      id: 'codegraph_identity_fixed',
-      passed: comparison?.codegraph_identity?.schema === 'lattice.rc1.codegraph_identity.v1',
+      id: 'sensor_identity_fixed',
+      passed: comparison?.sensor_identity?.schema === 'lattice.rc1.sensor_identity.v1',
     },
     {
       id: 'runtime_identity_fixed',
@@ -391,7 +391,7 @@ export function rc1V6ArtifactMediaType(relativePath) {
     throw new TypeError(`RC1 v6 artifact pathがexact setに存在しない: ${relativePath}`);
   }
   if (relativePath.endsWith('.json')) return 'application/json';
-  if (relativePath.endsWith('.mjs') || relativePath === IDENTITY_PATHS.codegraphExecutable) {
+  if (relativePath.endsWith('.mjs') || relativePath === IDENTITY_PATHS.sensorExecutable) {
     return 'application/javascript';
   }
   if (relativePath.endsWith('.patch')) return 'text/x-diff';
@@ -568,7 +568,7 @@ function executionValid(value, expected) {
     'base_sha',
     'elapsed_ms',
     'compiler_source_digest',
-    'codegraph_identity_digest',
+    'sensor_identity_digest',
     'runtime_identity_digest',
     'run_descriptor_digests',
     'transform_artifact_digest',
@@ -583,7 +583,7 @@ function executionValid(value, expected) {
     && Number.isFinite(value.elapsed_ms)
     && value.elapsed_ms >= 0
     && value.compiler_source_digest === expected.compilerSourceDigest
-    && value.codegraph_identity_digest === digestArtifact(expected.codegraphIdentity)
+    && value.sensor_identity_digest === digestArtifact(expected.sensorIdentity)
     && value.runtime_identity_digest === digestArtifact(expected.runtimeIdentity)
     && sameArtifact(value.run_descriptor_digests, expected.runDescriptorDigests)
     && value.transform_artifact_digest === expected.transformArtifactDigest
@@ -619,8 +619,8 @@ export function verifyRc1V6CampaignArtifactSet(options) {
     const compilerSourceDigest = sha256(context.payloads.get(IDENTITY_PATHS.compiler));
     const identitySourceBinding = sha256(context.payloads.get(IDENTITY_PATHS.oracleExecutor))
         === inputs.runtimeIdentity?.executor_source_digest
-      && sha256(context.payloads.get(IDENTITY_PATHS.codegraphExecutable))
-        === inputs.codegraphIdentity?.executable_digest;
+      && sha256(context.payloads.get(IDENTITY_PATHS.sensorExecutable))
+        === inputs.sensorIdentity?.executable_digest;
     check('identity_source_binding', identitySourceBinding);
     const baseInputsValid = validatePlanInput(inputs.planInput)
       && validateRc1BlackBoxOracle(inputs.oracle)
@@ -656,14 +656,14 @@ export function verifyRc1V6CampaignArtifactSet(options) {
         base_sha: context.manifest.base_sha,
         patch_digest: null,
         snapshot: controlSnapshot,
-        codegraph_identity: inputs.codegraphIdentity,
+        sensor_identity: inputs.sensorIdentity,
         query_set_digest: digestArtifact(inputs.querySet),
       },
       treatment: {
         base_sha: context.manifest.base_sha,
         patch_digest: behaviorEvidence.patch_digest,
         snapshot: treatmentSnapshot,
-        codegraph_identity: inputs.codegraphIdentity,
+        sensor_identity: inputs.sensorIdentity,
         query_set_digest: digestArtifact(inputs.querySet),
       },
     };
@@ -740,7 +740,7 @@ export function verifyRc1V6CampaignArtifactSet(options) {
       baseSha: context.manifest.base_sha,
       inputs,
       runtimeIdentity: inputs.runtimeIdentity,
-      codegraphIdentity: inputs.codegraphIdentity,
+      sensorIdentity: inputs.sensorIdentity,
       compilerSourceDigest,
       control: savedControl,
       treatment: savedTreatment,
@@ -765,7 +765,7 @@ export function verifyRc1V6CampaignArtifactSet(options) {
     check('execution_evidence', transform !== null && executionValid(execution, {
       baseSha: context.manifest.base_sha,
       compilerSourceDigest,
-      codegraphIdentity: inputs.codegraphIdentity,
+      sensorIdentity: inputs.sensorIdentity,
       runtimeIdentity: inputs.runtimeIdentity,
       runDescriptorDigests: runs.map(({ evidence_bundle_descriptor_digest: digest }) => digest),
       transformArtifactDigest: transform.artifact_digest,

package/src/rc1-v6-campaign.mjs

@@ -39,7 +39,7 @@ import { createRc1V6EvidenceBundleDescriptor } from './rc1-v6-causal-binding.mjs
 import { runRc1V5Campaign } from './rc1-v5-campaign.mjs';
 import {
   bindRc1V6EvidenceBundle,
-  captureRc1V6CodegraphExecutable,
+  captureRc1V6LatticeSensorExecutable,
   compileRc1V6BoundaryCondition,
   createRc1V6ConditionRun,
   sourceSnapshotFromRc1BehaviorSurface,
@@ -294,24 +294,24 @@ export async function runRc1V6Campaign(options = {}) {
     .stdout.toString('utf8').trim();
   if (!GIT_SHA1.test(baseSha)) throw new TypeError('RC1 v6 campaign base SHA is invalid');
   const startedAt = performance.now();
-  const [codegraphCapture, compilerSourceBytes, oracleExecutorBytes] = await Promise.all([
-    captureRc1V6CodegraphExecutable(),
+  const [sensorCapture, compilerSourceBytes, oracleExecutorBytes] = await Promise.all([
+    captureRc1V6LatticeSensorExecutable(),
     readFile(new URL('./boundary-compiler.mjs', import.meta.url)),
     readFile(new URL('./rc1-black-box-oracle.mjs', import.meta.url)),
   ]);
-  const codegraphIdentity = codegraphCapture.identity;
+  const sensorIdentity = sensorCapture.identity;
   const runtimeIdentity = await createRc1V6OracleRuntimeIdentity();
   if (runtimeIdentity.executor_source_digest !== sha256(oracleExecutorBytes)) {
     throw new TypeError('RC1 v6 oracle runtime identityが保存executor bytesと一致しない');
   }
   const v5 = await runRc1V5Campaign({ repoRoot, baseRef: baseSha, inputs: fixedInputs });
-  const [finalCodegraphCapture, finalCompilerSourceBytes, finalOracleExecutorBytes] =
+  const [finalLatticeSensorCapture, finalCompilerSourceBytes, finalOracleExecutorBytes] =
     await Promise.all([
-      captureRc1V6CodegraphExecutable(),
+      captureRc1V6LatticeSensorExecutable(),
       readFile(new URL('./boundary-compiler.mjs', import.meta.url)),
       readFile(new URL('./rc1-black-box-oracle.mjs', import.meta.url)),
     ]);
-  if (!isDeepStrictEqual(codegraphCapture, finalCodegraphCapture)
+  if (!isDeepStrictEqual(sensorCapture, finalLatticeSensorCapture)
     || !compilerSourceBytes.equals(finalCompilerSourceBytes)
     || !oracleExecutorBytes.equals(finalOracleExecutorBytes)) {
     throw new TypeError('RC1 v6実行主体のidentityがcampaign中にdriftした');
@@ -343,7 +343,7 @@ export async function runRc1V6Campaign(options = {}) {
     base_sha: baseSha,
     patch_digest: bundle.condition === 'treatment' ? v5.transform.artifact.patch.digest : null,
     snapshot: bundle.condition === 'treatment' ? treatmentSnapshot : controlSnapshot,
-    codegraph_identity: codegraphIdentity,
+    sensor_identity: sensorIdentity,
     query_set_digest: digestArtifact(fixedInputs.querySet),
   }));
   const runs = evidenceBundles.map(createRc1V6ConditionRun);
@@ -355,14 +355,14 @@ export async function runRc1V6Campaign(options = {}) {
     base_sha: baseSha,
     patch_digest: null,
     snapshot: controlSnapshot,
-    codegraph_identity: codegraphIdentity,
+    sensor_identity: sensorIdentity,
     query_set_digest: digestArtifact(fixedInputs.querySet),
   };
   const treatmentExpected = {
     base_sha: baseSha,
     patch_digest: v5.transform.artifact.patch.digest,
     snapshot: treatmentSnapshot,
-    codegraph_identity: codegraphIdentity,
+    sensor_identity: sensorIdentity,
     query_set_digest: digestArtifact(fixedInputs.querySet),
   };
   const control = compileCondition({
@@ -419,7 +419,7 @@ export async function runRc1V6Campaign(options = {}) {
     baseSha,
     inputs: fixedInputs,
     runtimeIdentity,
-    codegraphIdentity,
+    sensorIdentity,
     compilerSourceDigest,
     control,
     treatment,
@@ -443,7 +443,7 @@ export async function runRc1V6Campaign(options = {}) {
     base_sha: baseSha,
     elapsed_ms: roundedMilliseconds(startedAt),
     compiler_source_digest: compilerSourceDigest,
-    codegraph_identity_digest: digestArtifact(codegraphIdentity),
+    sensor_identity_digest: digestArtifact(sensorIdentity),
     runtime_identity_digest: digestArtifact(runtimeIdentity),
     run_descriptor_digests: runs.map(({ evidence_bundle_descriptor_digest: digest }) => digest),
     transform_artifact_digest: transform.artifact_digest,
@@ -458,11 +458,11 @@ export async function runRc1V6Campaign(options = {}) {
     base_sha: baseSha,
     inputs: fixedInputs,
     runtime_identity: runtimeIdentity,
-    codegraph_identity: codegraphIdentity,
+    sensor_identity: sensorIdentity,
     identity_sources: {
       compiler: compilerSourceBytes,
       oracle_executor: oracleExecutorBytes,
-      codegraph_executable: codegraphCapture.executable_bytes,
+      sensor_executable: sensorCapture.executable_bytes,
     },
     evidence_bundles: evidenceBundles,
     runs,
@@ -490,10 +490,10 @@ function artifactFiles(result, rejectedPlanBytes, phaseDecisionBytes) {
     files.set(relativePath, jsonBytes(result.inputs[key]));
   }
   files.set('inputs/oracle-runtime-identity.json', jsonBytes(result.runtime_identity));
-  files.set('inputs/codegraph-identity.json', jsonBytes(result.codegraph_identity));
+  files.set('inputs/lattice-sensor-identity.json', jsonBytes(result.sensor_identity));
   files.set('identity/boundary-compiler.mjs', Buffer.from(result.identity_sources.compiler));
   files.set('identity/black-box-oracle.mjs', Buffer.from(result.identity_sources.oracle_executor));
-  files.set('identity/codegraph-executable', Buffer.from(result.identity_sources.codegraph_executable));
+  files.set('identity/lattice-sensor-executable', Buffer.from(result.identity_sources.sensor_executable));
   for (const bundle of result.evidence_bundles) {
     files.set(`evidence/${bundle.run_id}.json`, jsonBytes(bundle));
   }

package/src/rc1-v6-causal-binding.mjs

@@ -262,17 +262,19 @@ function validSourceSnapshot(value) {
   return value.files.every(({ path }, index) => index === 0 || value.files[index - 1].path < path);
 }
 
-function validCodegraphIdentity(value) {
+function validLatticeSensorIdentity(value) {
   return exactRecord(value, [
     'schema',
     'version',
     'executable_ref',
     'executable_digest',
   ])
-    && value.schema === 'lattice.rc1.codegraph_identity.v1'
+    && value.schema === 'lattice.rc1.sensor_identity.v1'
     && typeof value.version === 'string'
     && /^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(value.version)
-    && value.executable_ref === 'codegraph'
+    // `sensor` is accepted only as an immutable pre-cutover artifact value.
+    // New captures always emit `lattice-sensor`.
+    && (value.executable_ref === 'lattice-sensor' || value.executable_ref === 'sensor')
     && SHA256.test(value.executable_digest);
 }
 
@@ -297,7 +299,7 @@ export function createRc1V6EvidenceBundleDescriptor(bundle) {
 }
 
 /**
- * v6 Codegraph runを、独立したsource／tool期待値と保存raw evidenceへcross-bindする。
+ * v6 LatticeSensor runを、独立したsource／tool期待値と保存raw evidenceへcross-bindする。
  */
 export function verifyRc1V6RunEvidence(options) {
   if (!exactRecord(options, ['run', 'bundle', 'expected'])) {
@@ -336,14 +338,14 @@ export function verifyRc1V6RunEvidence(options) {
     'base_sha',
     'patch_digest',
     'snapshot',
-    'codegraph_identity',
+    'sensor_identity',
     'query_set_digest',
   ])
     && GIT_SHA1.test(expected.base_sha)
     && (expected.patch_digest === null
       || (typeof expected.patch_digest === 'string' && SHA256.test(expected.patch_digest)))
     && validSourceSnapshot(expected.snapshot)
-    && validCodegraphIdentity(expected.codegraph_identity)
+    && validLatticeSensorIdentity(expected.sensor_identity)
     && SHA256.test(expected.query_set_digest);
   const measurement = bundleValid ? bundle.measurement : null;
   const measurementValid = exactRecord(measurement, [
@@ -352,19 +354,19 @@ export function verifyRc1V6RunEvidence(options) {
     'patch_digest',
     'snapshot',
     'snapshot_digest',
-    'codegraph_identity',
-    'codegraph_identity_digest',
+    'sensor_identity',
+    'sensor_identity_digest',
     'query_set_digest',
     'raw_evidence_digest',
   ])
-    && measurement.schema === 'lattice.rc1.codegraph_measurement.v1'
+    && measurement.schema === 'lattice.rc1.sensor_measurement.v1'
     && GIT_SHA1.test(measurement.base_sha)
     && (measurement.patch_digest === null
       || (typeof measurement.patch_digest === 'string' && SHA256.test(measurement.patch_digest)))
     && validSourceSnapshot(measurement.snapshot)
     && SHA256.test(measurement.snapshot_digest)
-    && validCodegraphIdentity(measurement.codegraph_identity)
-    && SHA256.test(measurement.codegraph_identity_digest)
+    && validLatticeSensorIdentity(measurement.sensor_identity)
+    && SHA256.test(measurement.sensor_identity_digest)
     && SHA256.test(measurement.query_set_digest)
     && SHA256.test(measurement.raw_evidence_digest);
 
@@ -394,10 +396,10 @@ export function verifyRc1V6RunEvidence(options) {
         && isDeepStrictEqual(measurement.snapshot, expected.snapshot),
     },
     {
-      id: 'codegraph_identity',
+      id: 'sensor_identity',
       passed: measurementValid && expectedValid
-        && measurement.codegraph_identity_digest === safeDigest(measurement.codegraph_identity)
-        && isDeepStrictEqual(measurement.codegraph_identity, expected.codegraph_identity),
+        && measurement.sensor_identity_digest === safeDigest(measurement.sensor_identity)
+        && isDeepStrictEqual(measurement.sensor_identity, expected.sensor_identity),
     },
     {
       id: 'source_projection',