@quolu/lattice 0.1.0 → 0.12.2

package/src/runtime-direct-os-observer.mjs

@@ -0,0 +1,284 @@
+import { execFile } from 'node:child_process';
+import { lstat, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { digestArtifact } from './artifact-contracts.mjs';
+import { selfDigest } from './runtime-contracts.mjs';
+import { validateProcessStartIdentity } from './runtime-controller-protocol.mjs';
+import { captureWorktreeDiff } from './runtime-diff-observer.mjs';
+
+const execFileAsync = promisify(execFile);
+const GIT_SHA1 = /^[0-9a-f]{40}$/;
+const SHA256 = /^[0-9a-f]{64}$/;
+
+export class DirectOsObservationError extends Error {
+  constructor(detail) {
+    super(`HOLD_ACKS_INCOMPLETE: ${detail}`);
+    this.name = 'DirectOsObservationError';
+    this.code = 'HOLD_ACKS_INCOMPLETE';
+    this.detail = detail;
+  }
+}
+
+function fail(detail) {
+  throw new DirectOsObservationError(detail);
+}
+
+function positivePid(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function identityFor(pid, startedIdentity) {
+  const identity = {
+    schema: 'lattice.process_start_identity.v1',
+    platform: process.platform,
+    pid,
+    started_identity: startedIdentity,
+    identity_digest: '',
+  };
+  identity.identity_digest = selfDigest(identity, 'identity_digest');
+  return identity;
+}
+
+function validExpectedProcess(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).sort().join('\0') === ['pid', 'process_group_id', 'process_start_identity'].sort().join('\0')
+    && positivePid(value.pid) && positivePid(value.process_group_id)
+    && validateProcessStartIdentity(value.process_start_identity)
+    && value.process_start_identity.pid === value.pid;
+}
+
+function validateResolvedBinding(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)
+    || !positivePid(value.process_pid) || !positivePid(value.process_group_id)
+    || !validateProcessStartIdentity(value.process_start_identity)
+    || value.process_start_identity.pid !== value.process_pid
+    || !Array.isArray(value.process_children)
+    || !value.process_children.every(validExpectedProcess)
+    || typeof value.worktree_path !== 'string' || !path.isAbsolute(value.worktree_path)
+    || typeof value.base_sha !== 'string' || !GIT_SHA1.test(value.base_sha)) {
+    fail('observation binding不正');
+  }
+  const pids = [value.process_pid, ...value.process_children.map((child) => child.pid)];
+  if (new Set(pids).size !== pids.length) fail('observation bindingのPID重複');
+  if (value.process_children.some((child) => child.process_group_id !== value.process_group_id)) {
+    fail('observation binding内のprocess group不一致');
+  }
+}
+
+async function runPsSnapshot() {
+  try {
+    const { stdout } = await execFileAsync('/bin/ps', [
+      '-axo', 'pid=,ppid=,pgid=,state=,lstart=',
+    ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+    return stdout;
+  } catch (error) {
+    fail(`ps観測失敗: ${error?.code ?? error?.message ?? 'unknown'}`);
+  }
+}
+
+function parsePsSnapshot(stdout) {
+  if (typeof stdout !== 'string') fail('ps観測結果が文字列でない');
+  const records = new Map();
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const match = line.match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+    if (!match) fail(`ps観測結果を解析できない: ${line}`);
+    const pid = Number(match[1]);
+    const record = {
+      pid,
+      parent_pid: Number(match[2]),
+      process_group_id: Number(match[3]),
+      raw_state: match[4],
+      started_identity: match[5].trim(),
+    };
+    if (!positivePid(record.pid) || !Number.isSafeInteger(record.parent_pid) || record.parent_pid < 0
+      || !positivePid(record.process_group_id) || record.started_identity.length === 0
+      || records.has(pid)) fail('ps観測結果のprocess record不正');
+    records.set(pid, record);
+  }
+  if (records.size === 0) fail('ps観測結果が空');
+  return records;
+}
+
+async function takePsSnapshot(psSnapshot) {
+  try {
+    return parsePsSnapshot(await psSnapshot());
+  } catch (error) {
+    if (error instanceof DirectOsObservationError) throw error;
+    fail(`ps観測失敗: ${error?.code ?? error?.message ?? 'unknown'}`);
+  }
+}
+
+function descendantPids(records, rootPid) {
+  const found = new Set();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const record of records.values()) {
+      if (record.pid !== rootPid && !found.has(record.pid)
+        && (record.parent_pid === rootPid || found.has(record.parent_pid))) {
+        found.add(record.pid);
+        changed = true;
+      }
+    }
+  }
+  return found;
+}
+
+function stateOf(record) {
+  if (record.raw_state.startsWith('T')) return 'stopped';
+  if (record.raw_state.startsWith('Z')) return 'zombie';
+  fail(`processがquiescedでない: ${record.pid} (${record.raw_state})`);
+}
+
+function verifyProcess(expected, actual, label) {
+  if (!actual) fail(`${label} processが見つからない: ${expected.pid}`);
+  const observedIdentity = identityFor(actual.pid, actual.started_identity);
+  if (observedIdentity.identity_digest !== expected.process_start_identity.identity_digest) {
+    fail(`${label} PID再利用又はstart identity差替え: ${expected.pid}`);
+  }
+  if (actual.process_group_id !== expected.process_group_id) {
+    fail(`${label} process group不一致: ${expected.pid}`);
+  }
+  return {
+    pid: actual.pid,
+    parent_pid: actual.parent_pid,
+    process_start_identity_digest: observedIdentity.identity_digest,
+    process_group_id: actual.process_group_id,
+    state: stateOf(actual),
+  };
+}
+
+function sameDirectoryIdentity(before, after) {
+  return before.dev === after.dev && before.ino === after.ino;
+}
+
+async function inspectWorktree(worktreePath, expectedRealpath = null) {
+  let info;
+  let observedRealpath;
+  try {
+    info = await lstat(worktreePath);
+    observedRealpath = await realpath(worktreePath);
+  } catch (error) {
+    fail(`worktree観測失敗: ${error?.code ?? error?.message ?? 'unknown'}`);
+  }
+  if (!info.isDirectory() || info.isSymbolicLink()) fail('worktreeがreal directoryでない');
+  if (observedRealpath !== worktreePath) fail('worktree pathがsymlink又は非canonical');
+  if (expectedRealpath !== null && observedRealpath !== expectedRealpath) fail('worktree realpath差替え');
+  return { info, observedRealpath };
+}
+
+/** durable bindingへ保存するためのprocess start identityをDirect OSから取得する。 */
+export async function observeDirectOsProcessStartIdentity(pid, { psSnapshot = runPsSnapshot } = {}) {
+  if (!positivePid(pid) || typeof psSnapshot !== 'function') fail('process identity観測入力不正');
+  const records = await takePsSnapshot(psSnapshot);
+  const record = records.get(pid);
+  if (!record) fail(`processが見つからない: ${pid}`);
+  return identityFor(pid, record.started_identity);
+}
+
+/**
+ * RuntimeManagedSupervisorのprocessObserverとして渡すDirect OS observer。
+ * resolverはjournal由来のimmutable bindingへprocess_pid、start identity、PGID、
+ * process_children、worktree_path、base_shaを補完する。
+ */
+export function createDirectOsProcessObserver({
+  resolveObservationBinding,
+  psSnapshot = runPsSnapshot,
+  captureCheckpoint = captureWorktreeDiff,
+} = {}) {
+  if (typeof resolveObservationBinding !== 'function' || typeof psSnapshot !== 'function'
+    || typeof captureCheckpoint !== 'function') fail('Direct OS observer dependency不足');
+  return async ({ kind, binding, ack }) => {
+    if (!['quiescence', 'rebind'].includes(kind)) fail('未知のDirect OS observation kind');
+    const resolved = await resolveObservationBinding({
+      binding: structuredClone(binding),
+      ack: structuredClone(ack),
+    });
+    validateResolvedBinding(resolved);
+
+    const records = await takePsSnapshot(psSnapshot);
+    const expectedRoot = {
+      pid: resolved.process_pid,
+      process_group_id: resolved.process_group_id,
+      process_start_identity: resolved.process_start_identity,
+    };
+    const root = verifyProcess(expectedRoot, records.get(resolved.process_pid), 'root');
+    const actualDescendants = descendantPids(records, resolved.process_pid);
+    const expectedDescendants = new Set(resolved.process_children.map((child) => child.pid));
+    for (const pid of expectedDescendants) {
+      if (!actualDescendants.has(pid)) fail(`保存済みchildが見つからない: ${pid}`);
+    }
+    for (const pid of actualDescendants) {
+      if (!expectedDescendants.has(pid)) fail(`未記録childを検出: ${pid}`);
+    }
+    const expectedGroup = new Set([resolved.process_pid, ...expectedDescendants]);
+    for (const record of records.values()) {
+      if (record.process_group_id === resolved.process_group_id && !expectedGroup.has(record.pid)) {
+        fail(`未記録process group memberを検出: ${record.pid}`);
+      }
+    }
+    const children = resolved.process_children
+      .map((expected) => verifyProcess(expected, records.get(expected.pid), 'child'))
+      .sort((left, right) => left.pid - right.pid);
+
+    const before = await inspectWorktree(resolved.worktree_path, resolved.worktree_realpath ?? null);
+    let checkpoint;
+    try {
+      checkpoint = await captureCheckpoint({ worktreePath: before.observedRealpath, baseSha: resolved.base_sha });
+    } catch (error) {
+      if (error instanceof DirectOsObservationError) throw error;
+      fail(`checkpoint観測失敗: ${error?.message ?? 'unknown'}`);
+    }
+    if (checkpoint === null || typeof checkpoint !== 'object' || !SHA256.test(checkpoint.checkpoint_digest ?? '')) {
+      fail('checkpoint観測結果不正');
+    }
+    const after = await inspectWorktree(resolved.worktree_path, before.observedRealpath);
+    if (!sameDirectoryIdentity(before.info, after.info)) fail('checkpoint観測中にworktreeが差替えられた');
+
+    const processObservation = {
+      schema: 'lattice.direct_process_observation.v2',
+      root,
+      children,
+      process_group_id: resolved.process_group_id,
+      quiesced: true,
+    };
+    const worktreeFingerprint = {
+      schema: 'lattice.direct_worktree_fingerprint.v1',
+      worktree_id: binding?.worktree_id ?? ack?.worktree_id,
+      worktree_realpath: after.observedRealpath,
+      checkpoint_digest: checkpoint.checkpoint_digest,
+    };
+    return {
+      quiesced: true,
+      process_observation_digest: digestArtifact(processObservation),
+      worktree_fingerprint_digest: digestArtifact(worktreeFingerprint),
+      final_checkpoint_digest: checkpoint.checkpoint_digest,
+      observation: processObservation,
+      worktree_fingerprint: worktreeFingerprint,
+      checkpoint,
+      write_enabled: false,
+    };
+  };
+}
+
+/** running=0の事実だけを表し、process停止証拠には昇格しないreceipt。 */
+export function createEmptyRunningObservationReceipt({ runId, barrierId, frozenEventDigest }) {
+  if (typeof runId !== 'string' || runId.length === 0
+    || typeof barrierId !== 'string' || barrierId.length === 0
+    || !SHA256.test(frozenEventDigest ?? '')) fail('empty running receipt入力不正');
+  const receipt = {
+    schema: 'lattice.empty_running_observation_receipt.v1',
+    run_id: runId,
+    barrier_id: barrierId,
+    frozen_event_digest: frozenEventDigest,
+    running_count: 0,
+    establishes_process_quiescence: false,
+    receipt_digest: '',
+  };
+  receipt.receipt_digest = selfDigest(receipt, 'receipt_digest');
+  return receipt;
+}

package/src/runtime-engine.mjs

@@ -1,6 +1,7 @@
 import { digestArtifact } from './artifact-contracts.mjs';
 import { digestRunEvent } from './runtime-event-store.mjs';
 import { projectRuntimeState } from './runtime-projection.mjs';
+import { isCanonicalUtcTimestamp } from './timestamp-contract.mjs';
 import {
   RUN_EVENT_KINDS,
   computeContextContentDigest,
@@ -33,7 +34,6 @@ const ENGINE_ACTOR = 'lattice-runtime';
 const FORBIDDEN_OPERATIONS = Object.freeze([
   'commit', 'push', 'branch', 'merge', 'rebase', 'reset', 'stash',
 ]);
-const TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 
 function fail(reason) {
   throw new TypeError(`runtime engine契約違反: ${reason}`);
@@ -55,7 +55,7 @@ function exactRecord(value, keys) {
 }
 
 function requireTimestamp(value) {
-  if (typeof value !== 'string' || !TIMESTAMP.test(value)) {
+  if (!isCanonicalUtcTimestamp(value)) {
     fail(`recordedAtがcanonical UTC timestampではない: ${String(value)}`);
   }
   return value;

package/src/runtime-errors.mjs

@@ -30,7 +30,7 @@ const LOCK_RETRY_MS = 100;
 const LOCK_TIMEOUT_MS = 5_000;
 
 const definitions = Object.freeze({
-  'LATTICE.CODEGRAPH_EVIDENCE_FAILED': { component: 'sensor_adapter', severity: 'high', template: 'Lattice codegraph evidence collection failed' },
+  'LATTICE.SENSOR_EVIDENCE_FAILED': { component: 'sensor_adapter', severity: 'high', template: 'LatticeSensor evidence collection failed' },
   'LATTICE.RUN_STORE_IO_FAILED': { component: 'run_store', severity: 'high', template: 'Lattice run store IO failed' },
   'LATTICE.EVENT_CHAIN_INTEGRITY_FAILED': { component: 'event_store', severity: 'high', template: 'Lattice run event chain integrity check failed' },
   'LATTICE.CLI_INTERNAL_FAILED': { component: 'cli', severity: 'high', template: 'Lattice CLI crashed outside the typed error contract' },

package/src/runtime-event-store.mjs

@@ -1,9 +1,9 @@
 import { canonicalizeArtifact } from './artifact-contracts.mjs';
 import {
   RUN_EVENT_KINDS,
-  selfDigest,
   validateRunEvent,
 } from './runtime-contracts.mjs';
+import { digestWithoutField, verifyLinearHashChain } from './hash-chain.mjs';
 
 // RC3 event store契約（ADR 0044 Decision 3）。
 // event storeはrun単位のappend-only canonical event列であり、`sequence`は0起点の
@@ -64,7 +64,7 @@ export function digestRunEvent(event) {
   if (event === null || typeof event !== 'object' || Array.isArray(event)) {
     throw new TypeError('run event契約違反: eventはplain objectでなければならない');
   }
-  return selfDigest(event, 'event_digest');
+  return digestWithoutField(event, 'event_digest', canonicalizeArtifact);
 }
 
 /**
@@ -134,7 +134,7 @@ export function verifyRunEventChain(options = {}) {
       sequence: 0,
       previous_digest: null,
     };
-    probe.event_digest = selfDigest(probe, 'event_digest');
+    probe.event_digest = digestWithoutField(probe, 'event_digest', canonicalizeArtifact);
     return validateRunEvent(probe);
   });
   checks.push(check('event_shape', shapeOk));
@@ -145,9 +145,12 @@ export function verifyRunEventChain(options = {}) {
   const knownKindOk = shapeOk && events.every((event) => RUN_EVENT_KINDS.includes(event.kind));
   checks.push(check('unknown_kind', knownKindOk));
 
-  const eventDigestOk = shapeOk && events.every((event) => (
-    event.event_digest === selfDigest(event, 'event_digest')
-  ));
+  const sharedFailures = shapeOk ? verifyLinearHashChain({
+    entries: events,
+    canonicalize: canonicalizeArtifact,
+    digestField: 'event_digest',
+  }) : new Set();
+  const eventDigestOk = shapeOk && !sharedFailures.has('event_digest_mismatch');
   checks.push(check('event_digest_mismatch', eventDigestOk));
 
   const redactionOk = shapeOk && events.every((event) => (
@@ -155,11 +158,7 @@ export function verifyRunEventChain(options = {}) {
   ));
   checks.push(check('payload_redaction', redactionOk));
 
-  // 保存配列の物理順序はsequence順と一致しなければならない（append-only列の
-  // 保存bytes自体が順序judgementと矛盾しないための条件。ADR 0044 Decision 3.4）。
-  const storageOrderOk = shapeOk && events.every((event, index) => (
-    index === 0 || events[index - 1].sequence < event.sequence
-  ));
+  const storageOrderOk = shapeOk && !sharedFailures.has('storage_order');
   checks.push(check('storage_order', storageOrderOk));
 
   let duplicateOk = shapeOk;
@@ -168,38 +167,11 @@ export function verifyRunEventChain(options = {}) {
   let genesisOk = shapeOk;
   let chainOk = shapeOk;
   if (shapeOk) {
-    const bySequence = new Map();
-    for (const event of events) {
-      const bytes = canonicalizeArtifact(event);
-      const seen = bySequence.get(event.sequence);
-      if (seen === undefined) {
-        bySequence.set(event.sequence, { first: event, bytes: new Set([bytes]), count: 1 });
-      } else {
-        seen.count += 1;
-        seen.bytes.add(bytes);
-      }
-    }
-    for (const entry of bySequence.values()) {
-      if (entry.count > 1 && entry.bytes.size === 1) duplicateOk = false;
-      if (entry.bytes.size > 1) forkOk = false;
-    }
-
-    const sequences = [...bySequence.keys()].sort((left, right) => left - right);
-    gapOk = sequences[0] === 0
-      && sequences.every((sequence, index) => sequence === index);
-    genesisOk = bySequence.get(0) !== undefined
-      && bySequence.get(0).first.previous_digest === null
-      && events.every((event) => (event.sequence === 0) === (event.previous_digest === null));
-
-    for (const [index, sequence] of sequences.entries()) {
-      if (index === 0) continue;
-      const previous = bySequence.get(sequences[index - 1]).first;
-      const current = bySequence.get(sequence).first;
-      if (current.previous_digest !== previous.event_digest) {
-        chainOk = false;
-        break;
-      }
-    }
+    duplicateOk = !sharedFailures.has('duplicate_event');
+    forkOk = !sharedFailures.has('sequence_fork');
+    gapOk = !sharedFailures.has('sequence_gap');
+    genesisOk = !sharedFailures.has('genesis_binding');
+    chainOk = !sharedFailures.has('digest_chain_mismatch');
   }
   checks.push(check('duplicate_event', duplicateOk));
   checks.push(check('sequence_fork', forkOk));

package/src/runtime-front-end.mjs

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 
 import { digestArtifact } from './artifact-contracts.mjs';
 import { compileBoundaryObservationV2 } from './boundary-observation-compiler-v2.mjs';
-import { portableCodegraphOutcome } from './codegraph-adapter.mjs';
+import { portableSensorOutcome } from './sensor-adapter.mjs';
 import { compileSchedulabilityGraphV2 } from './schedulability-compiler-v2.mjs';
 import { verifySchedulabilityPlanV2 } from './schedulability-verifier-v2.mjs';
 import {
@@ -16,11 +16,11 @@ import {
 /**
  * RC3-D generic front-end（ADR 0044 Decision 2・8、plan RC3-D）。
  *
- * `lattice.run_request.v1`のmanual witnessとfresh Codegraph観測evidenceから、
+ * `lattice.run_request.v1`のmanual witnessとfresh LatticeSensor観測evidenceから、
  * fixture名・期待conflict・期待waveの分岐なしに`lattice.runtime_plan.v1`と
  * TODOごとの`lattice.boundary_manifest.v2`をcompileする。
  *
- * adapter契約（witness.codegraph_provenance、RC3-Dで固定）:
+ * adapter契約（witness.sensor_provenance、RC3-Dで固定）:
  *   { queries: [{ query_id, expect }] }
  *   expect = { kind: 'symbol', name, path } — query outcomeにnode.name/filePathの
  *            exact一致がちょうど1件あることを要求（fuzzy解決の誤読防止）
@@ -32,7 +32,7 @@ import {
  *   NODE_LIMIT_EXCEEDED / BOUNDARY_UNKNOWN / SEARCH_BUDGET_EXHAUSTED /
  *   QUERY_DRIFT / AFFECTED_TEST_DRIFT
  *
- * Codegraph raw telemetryはevidence captureに留め、plan・manifest identityへは
+ * LatticeSensor raw telemetryはevidence captureに留め、plan・manifest identityへは
  * portable outcome projectionのcanonical digestだけを入れる（Decision 10.4）。
  */
 
@@ -124,10 +124,10 @@ function nonDispatchable(code, detail) {
   return { outcome: 'non_dispatchable', code, detail };
 }
 
-/** query set（run_request.codegraph_query_set）のexact shapeを検査する。 */
+/** query set（run_request.sensor_query_set）のexact shapeを検査する。 */
 function normalizeQuerySet(querySet) {
-  if (!exactRecord(querySet, ['queries'])) fail('codegraph_query_set shapeが不正');
-  if (!Array.isArray(querySet.queries)) fail('codegraph_query_set.queriesがarrayではない');
+  if (!exactRecord(querySet, ['queries'])) fail('sensor_query_set shapeが不正');
+  if (!Array.isArray(querySet.queries)) fail('sensor_query_set.queriesがarrayではない');
   const byId = new Map();
   for (const query of querySet.queries) {
     const keys = Object.hasOwn(query ?? {}, 'target')
@@ -150,7 +150,7 @@ function normalizeQuerySet(querySet) {
  * evidence = { outcomes: [{ query_id, operation, status, raw }] }（query set順）
  */
 function normalizeEvidence(evidence, queryById) {
-  if (!exactRecord(evidence, ['outcomes'])) fail('codegraph evidence shapeが不正');
+  if (!exactRecord(evidence, ['outcomes'])) fail('sensor evidence shapeが不正');
   if (!Array.isArray(evidence.outcomes)) fail('evidence.outcomesがarrayではない');
   if (evidence.outcomes.length !== queryById.size) {
     fail(`evidence件数(${evidence.outcomes.length})がquery set件数(${queryById.size})と一致しない`);
@@ -168,7 +168,7 @@ function normalizeEvidence(evidence, queryById) {
     if (typeof outcome.status !== 'string' || outcome.status.length === 0) {
       fail('evidence outcome statusが不正');
     }
-    const portable = portableCodegraphOutcome(outcome.raw);
+    const portable = portableSensorOutcome(outcome.raw);
     byQueryId.set(outcome.query_id, {
       query_id: outcome.query_id,
       operation: outcome.operation,
@@ -187,13 +187,13 @@ function normalizeEvidence(evidence, queryById) {
 }
 
 function normalizeProvenanceQueries(witness, todoId) {
-  const provenance = witness.codegraph_provenance;
+  const provenance = witness.sensor_provenance;
   if (!exactRecord(provenance, ['queries']) || !Array.isArray(provenance.queries)) {
-    fail(`witness ${todoId}.codegraph_provenance shapeが不正`);
+    fail(`witness ${todoId}.sensor_provenance shapeが不正`);
   }
   return provenance.queries.map((entry) => {
     if (!exactRecord(entry, ['query_id', 'expect']) || !identifier(entry.query_id)) {
-      fail(`witness ${todoId}.codegraph_provenance entry shapeが不正`);
+      fail(`witness ${todoId}.sensor_provenance entry shapeが不正`);
     }
     const expect = entry.expect;
     if (!plainRecord(expect) || !EXPECT_KINDS.has(expect.kind)) {
@@ -236,7 +236,7 @@ function rawPayload(raw) {
 }
 
 /**
- * affected outcomeのpayloadを取り出す。codegraph-adapterのper-target形
+ * affected outcomeのpayloadを取り出す。lattice-sensor-adapterのper-target形
  * （`{targets: [{target, outcome, data}]}`）と直接data形の両方を受ける。
  */
 function affectedPayload(raw, expectPath) {
@@ -262,7 +262,7 @@ function entryNode(entry) {
 }
 
 /**
- * 束縛queryのoutcomeへexpectをexact照合し、codegraph statusを決める。
+ * 束縛queryのoutcomeへexpectをexact照合し、sensor statusを決める。
  * fuzzy解決・空結果は依存なしへ丸めず、unknown系statusへ落とす（AGENTS.md）。
  */
 function resolveBindingStatus(binding, outcome) {
@@ -331,7 +331,7 @@ function candidateProvenance(request) {
 }
 
 /**
- * `collectCodegraphEvidence`のraw収集結果を、query set順へexact整合した
+ * `collectSensorEvidence`のraw収集結果を、query set順へexact整合した
  * front-end evidence契約（`{outcomes: [{query_id, operation, status, raw}]}`）へ写す。
  * 件数・id・operationの不一致はfail closed。
  */
@@ -369,15 +369,15 @@ export function evidenceFromCollectedOutcomes(options = {}) {
 }
 
 /**
- * run_requestとcodegraph evidenceからobservation set・graph・planを一括compileする。
+ * run_requestとsensor evidenceからobservation set・graph・planを一括compileする。
  * 成功時はdispatchable outcome、契約内の識別可能な不成立はtyped non-dispatchable、
  * 入力shape違反はTypeErrorでfail closed。
  */
 export function compileRuntimePlanV1(options = {}) {
-  if (!exactRecord(options, ['request', 'codegraphEvidence', 'planRef', 'planEpoch', 'predecessorRefs'])) {
+  if (!exactRecord(options, ['request', 'sensorEvidence', 'planRef', 'planEpoch', 'predecessorRefs'])) {
     fail('compileRuntimePlanV1 optionsがexact shapeでない');
   }
-  const { request, codegraphEvidence, planRef, planEpoch, predecessorRefs } = options;
+  const { request, sensorEvidence, planRef, planEpoch, predecessorRefs } = options;
   if (!validateRunRequest(request)) fail('run_request.v1がcontractを満たさない');
   if (!identifier(planRef)) fail('planRefがidentifierではない');
   if (!Number.isSafeInteger(planEpoch) || planEpoch < 0) fail('planEpochが不正');
@@ -385,8 +385,8 @@ export function compileRuntimePlanV1(options = {}) {
     fail('predecessorRefsがstring arrayではない');
   }
 
-  const queryById = normalizeQuerySet(request.codegraph_query_set);
-  const outcomeByQueryId = normalizeEvidence(codegraphEvidence, queryById);
+  const queryById = normalizeQuerySet(request.sensor_query_set);
+  const outcomeByQueryId = normalizeEvidence(sensorEvidence, queryById);
 
   const todoIds = request.todos.map((todo) => todo.todo_id);
 
@@ -425,7 +425,7 @@ export function compileRuntimePlanV1(options = {}) {
   const unknowns = [];
   if (statusOutcome.status !== 'ready') {
     for (const todoId of todoIds) {
-      unknowns.push({ todo_id: todoId, kind: `codegraph_${statusOutcome.status}`, ref: statusQueries[0].id });
+      unknowns.push({ todo_id: todoId, kind: `sensor_${statusOutcome.status}`, ref: statusQueries[0].id });
     }
   }
 
@@ -435,7 +435,7 @@ export function compileRuntimePlanV1(options = {}) {
     for (const binding of bindingsByTodo.get(todoId)) {
       const resolved = resolveBindingStatus(binding, outcomeByQueryId.get(binding.query_id));
       if (resolved !== 'ready') {
-        unknowns.push({ todo_id: todoId, kind: `codegraph_${resolved}`, ref: binding.query_id });
+        unknowns.push({ todo_id: todoId, kind: `sensor_${resolved}`, ref: binding.query_id });
       }
     }
   }
@@ -492,7 +492,7 @@ export function compileRuntimePlanV1(options = {}) {
         }
       }
       if (covering.length === 0) {
-        unknowns.push({ todo_id: todoId, kind: 'codegraph_unbound', ref: `${own.kind}:${own.target}` });
+        unknowns.push({ todo_id: todoId, kind: 'sensor_unbound', ref: `${own.kind}:${own.target}` });
       }
     }
   }
@@ -592,7 +592,7 @@ export function compileRuntimePlanV1(options = {}) {
       todo_ids: [...group.todoIds].sort(compareText),
       provenance: [
         {
-          source: 'codegraph',
+          source: 'sensor',
           evidence_ref: coveringQueryId,
           evidence_digest: outcome.portable_digest,
           status,
@@ -660,7 +660,7 @@ export function compileRuntimePlanV1(options = {}) {
     source: {
       snapshot_digest: digestArtifact({ base_sha: request.repo.base_sha }),
       candidate_witness_digest: digestArtifact(request.manual_witness),
-      query_set_digest: digestArtifact(request.codegraph_query_set),
+      query_set_digest: digestArtifact(request.sensor_query_set),
       manual_evidence_digest: request.request_digest,
     },
     capacity: request.capacity.executors,
@@ -698,7 +698,7 @@ export function compileRuntimePlanV1(options = {}) {
     for (const resource of resources) {
       if (!resource.todo_ids.includes(todoId)) continue;
       witnessProvenance[resource.resource_id] = resource.kind === 'symbol' || resource.kind === 'path'
-        ? 'codegraph'
+        ? 'sensor'
         : 'manual_state_effect';
     }
     const manifest = {