@quolu/lattice 0.52.0 → 0.52.2

package/src/treatment-runner.mjs

@@ -1,656 +1,656 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import {
-  access,
-  mkdtemp,
-  readFile,
-  rm,
-} from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { performance } from 'node:perf_hooks';
-
-import {
-  canonicalizeArtifact,
-  digestArtifact,
-  validateTransformArtifact,
-} from './artifact-contracts.mjs';
-import {
-  collectSensorEvidence,
-  portableSensorOutcome,
-} from './sensor-adapter.mjs';
-import { spawnSensorCli } from './sensor-runtime.mjs';
-import { compileTreatmentArtifacts } from './treatment-compiler.mjs';
-
-const SHA1 = /^[0-9a-f]{40}$/;
-const SHA256 = /^[0-9a-f]{64}$/;
-const PORTABLE_PROJECTION = 'lattice.sensor_portable_outcome.v1';
-const VERIFIER = Object.freeze({
-  id: 'dispatch-characterization',
-  command: 'node',
-  args: ['--test', '--test-reporter=dot', 'test/research-dispatch-record.test.mjs'],
-});
-
-function fail(reason) {
-  throw new TypeError(`treatment recompile契約違反: ${reason}`);
-}
-
-function exactRecord(value, keys) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)
-    || Object.getPrototypeOf(value) !== Object.prototype) {
-    return false;
-  }
-  const actual = Object.keys(value).sort();
-  const expected = [...keys].sort();
-  return actual.length === expected.length
-    && actual.every((key, index) => key === expected[index]);
-}
-
-function sha256(value) {
-  return createHash('sha256').update(value).digest('hex');
-}
-
-function run(command, args, { cwd, env, input, allowExitCodes = [0] } = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      env,
-      shell: false,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    const stdout = [];
-    const stderr = [];
-    child.stdout.on('data', (chunk) => stdout.push(chunk));
-    child.stderr.on('data', (chunk) => stderr.push(chunk));
-    child.once('error', reject);
-    child.once('close', (code, signal) => {
-      const result = {
-        code,
-        signal,
-        stdout: Buffer.concat(stdout),
-        stderr: Buffer.concat(stderr),
-      };
-      if (allowExitCodes.includes(code) && signal === null) resolve(result);
-      else reject(Object.assign(
-        new Error(`${command} failed (${signal ?? code}): ${result.stderr.toString('utf8').trim()}`),
-        result,
-      ));
-    });
-    child.stdin.end(input);
-  });
-}
-
-function sensorEnvironment() {
-  const env = {
-    ...process.env,
-    LATTICE_SENSOR_NO_DAEMON: '1',
-    LATTICE_SENSOR_NO_WATCH: '1',
-    LATTICE_SENSOR_NO_UPDATE_CHECK: '1',
-    DO_NOT_TRACK: '1',
-    NO_COLOR: '1',
-  };
-  delete env.FORCE_COLOR;
-  return env;
-}
-
-function executeLatticeSensor({ args, cwd }) {
-  return new Promise((resolve) => {
-    const child = spawnSensorCli(args, {
-      cwd,
-      env: sensorEnvironment(),
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (chunk) => { stdout += chunk; });
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.once('error', (error) => {
-      resolve({ code: null, stdout, stderr, error: error.message });
-    });
-    child.once('close', (code) => resolve({ code, stdout, stderr }));
-  });
-}
-
-function artifactMeta(value) {
-  return exactRecord(value, ['digest', 'canonical_bytes'])
-    && typeof value.digest === 'string'
-    && SHA256.test(value.digest)
-    && Number.isSafeInteger(value.canonical_bytes)
-    && value.canonical_bytes > 0;
-}
-
-function artifactSet(value) {
-  return exactRecord(value, ['boundary_manifest', 'boundary_verdict', 'plan_graph'])
-    && Object.values(value).every(artifactMeta);
-}
-
-function assertPortableControlEvidence(evidence) {
-  if (!exactRecord(evidence, [
-    'schema',
-    'observed_at',
-    'head',
-    'executor_head',
-    'graph_digest_projection',
-    'input_digests',
-    'sensor',
-    'artifacts',
-    'observed_facts',
-    'presentation_note',
-  ])
-    || evidence.schema !== 'lattice.rc1.control_compilation_evidence.v2'
-    || evidence.graph_digest_projection !== PORTABLE_PROJECTION) {
-    fail('portable control evidence v2だけがrecompileへ進める');
-  }
-  if (typeof evidence.head !== 'string'
-    || !SHA1.test(evidence.head)
-    || typeof evidence.executor_head !== 'string'
-    || !SHA1.test(evidence.executor_head)
-    || !exactRecord(evidence.input_digests, [
-      'plan_input',
-      'query_set',
-      'manual_normal',
-      'manual_shared_state_negative',
-      'code_snapshot',
-    ])
-    || Object.values(evidence.input_digests).some((digest) => (
-      typeof digest !== 'string' || !SHA256.test(digest)
-    ))
-    || !exactRecord(evidence.artifacts, ['control', 'shared_state_negative'])
-    || !artifactSet(evidence.artifacts.control)
-    || !artifactSet(evidence.artifacts.shared_state_negative)
-    || !exactRecord(evidence.sensor, [
-      'version',
-      'file_count',
-      'node_count',
-      'edge_count',
-      'pending_changes',
-      'pending_refs',
-      'worktree_mismatch',
-      'fresh_index_repetitions',
-      'raw_outcomes_digests',
-      'raw_outcomes_equal',
-      'portable_outcomes_digest',
-      'portable_outcomes_equal',
-      'outcomes',
-    ])
-    || evidence.sensor.fresh_index_repetitions !== 2
-    || !Array.isArray(evidence.sensor.raw_outcomes_digests)
-    || evidence.sensor.raw_outcomes_digests.length !== 2
-    || evidence.sensor.raw_outcomes_digests.some((digest) => (
-      typeof digest !== 'string' || !SHA256.test(digest)
-    ))
-    || new Set(evidence.sensor.raw_outcomes_digests).size !== 2
-    || evidence.sensor.raw_outcomes_equal !== false
-    || typeof evidence.sensor.portable_outcomes_digest !== 'string'
-    || !SHA256.test(evidence.sensor.portable_outcomes_digest)
-    || evidence.sensor.portable_outcomes_equal !== true
-    || !Array.isArray(evidence.sensor.outcomes)
-    || evidence.sensor.outcomes.length === 0) {
-    fail('portable control evidence v2のdigest metadataが不正');
-  }
-}
-
-function assertTransformExecutionEvidence(evidence, {
-  transformArtifact,
-  transformPatch,
-  controlCompilationEvidence,
-  querySetDigest,
-  normal,
-}) {
-  if (!exactRecord(evidence, [
-    'schema',
-    'observed_at',
-    'executor_head',
-    'experiment_base_sha',
-    'control_compilation_evidence_schema',
-    'graph_digest_projection',
-    'input_digests',
-    'runs',
-    'artifacts',
-    'observed_facts',
-    'presentation_note',
-  ])
-    || evidence.schema !== 'lattice.rc1.seam_transform_execution_evidence.v2'
-    || typeof evidence.executor_head !== 'string'
-    || !SHA1.test(evidence.executor_head)
-    || evidence.experiment_base_sha !== transformArtifact.source.base_sha
-    || evidence.control_compilation_evidence_schema !== controlCompilationEvidence.schema
-    || evidence.graph_digest_projection !== PORTABLE_PROJECTION
-    || !exactRecord(evidence.input_digests, [
-      'boundary_manifest',
-      'boundary_verdict',
-      'control_plan',
-      'query_set',
-      'control_compilation_evidence',
-    ])
-    || !exactRecord(evidence.runs, [
-      'accepted_primary',
-      'accepted_repeat',
-      'scope_rejection',
-      'behavior_rejection',
-    ])
-    || !exactRecord(evidence.artifacts, [
-      'transform',
-      'scope_rejection',
-      'behavior_rejection',
-      'patch',
-    ])
-    || !artifactMeta(evidence.artifacts.transform)
-    || !artifactMeta(evidence.artifacts.scope_rejection)
-    || !artifactMeta(evidence.artifacts.behavior_rejection)
-    || !exactRecord(evidence.artifacts.patch, ['digest', 'bytes'])) {
-    fail('transform execution evidence v2が不正');
-  }
-  const transformArtifactDigest = digestArtifact(transformArtifact);
-  const transformCanonicalBytes = Buffer.byteLength(canonicalizeArtifact(transformArtifact));
-  if (evidence.input_digests.boundary_manifest !== normal.boundary_manifest
-    || evidence.input_digests.boundary_verdict !== normal.boundary_verdict
-    || evidence.input_digests.control_plan !== normal.plan_graph
-    || evidence.input_digests.query_set !== querySetDigest
-    || evidence.input_digests.control_compilation_evidence
-      !== digestArtifact(controlCompilationEvidence)
-    || evidence.runs.accepted_primary?.artifact_digest !== transformArtifactDigest
-    || evidence.runs.accepted_repeat?.artifact_digest !== transformArtifactDigest
-    || evidence.artifacts.transform.digest !== transformArtifactDigest
-    || evidence.artifacts.transform.canonical_bytes !== transformCanonicalBytes
-    || evidence.artifacts.patch.digest !== sha256(transformPatch)
-    || evidence.artifacts.patch.bytes !== transformPatch.byteLength
-    || evidence.observed_facts?.deterministic_repeat !== true
-    || evidence.observed_facts?.same_control_base !== true
-    || evidence.observed_facts?.portable_control_chain !== true
-    || evidence.observed_facts?.characterization_passed !== true
-    || evidence.observed_facts?.git_apply_check !== 'passed'
-    || evidence.observed_facts?.source_unchanged !== true
-    || evidence.observed_facts?.cleanup !== 'passed') {
-    fail('transform execution evidenceのpredecessor chainが一致しない');
-  }
-  return digestArtifact(evidence);
-}
-
-function bundleDigests(bundle) {
-  if (!exactRecord(bundle, ['boundary_manifest', 'boundary_verdict', 'plan_graph'])) {
-    fail('control artifact setが不正');
-  }
-  return {
-    boundary_manifest: digestArtifact(bundle.boundary_manifest),
-    boundary_verdict: digestArtifact(bundle.boundary_verdict),
-    plan_graph: digestArtifact(bundle.plan_graph),
-  };
-}
-
-function assertAdmission({
-  planInput,
-  manualNormal,
-  manualNegative,
-  querySet,
-  transformArtifact,
-  transformExecutionEvidence,
-  transformPatch,
-  controlCompilationEvidence,
-  control,
-}) {
-  for (const value of [
-    planInput,
-    manualNormal,
-    manualNegative,
-    querySet,
-    transformArtifact,
-    transformExecutionEvidence,
-    controlCompilationEvidence,
-    control,
-  ]) {
-    canonicalizeArtifact(value);
-  }
-  if (!validateTransformArtifact(transformArtifact) || transformArtifact.status !== 'accepted') {
-    fail('accepted transform artifactが必要');
-  }
-  if (!Buffer.isBuffer(transformPatch)
-    || sha256(transformPatch) !== transformArtifact.patch.digest
-    || transformPatch.byteLength !== transformArtifact.patch.bytes) {
-    fail('transform patch digestまたはpatch bytesがartifactと一致しない');
-  }
-  assertPortableControlEvidence(controlCompilationEvidence);
-  if (!exactRecord(control, ['normal', 'negative'])) fail('control artifact setが不正');
-  const normal = bundleDigests(control.normal);
-  const negative = bundleDigests(control.negative);
-  const evidence = controlCompilationEvidence;
-  if (evidence.head !== transformArtifact.source.base_sha
-    || evidence.input_digests.plan_input !== digestArtifact(planInput)
-    || evidence.input_digests.query_set !== digestArtifact(querySet)
-    || evidence.input_digests.manual_normal !== digestArtifact(manualNormal)
-    || evidence.input_digests.manual_shared_state_negative !== digestArtifact(manualNegative)
-    || evidence.input_digests.code_snapshot !== transformArtifact.source.code_snapshot_digest
-    || evidence.artifacts.control.boundary_manifest.digest !== normal.boundary_manifest
-    || evidence.artifacts.control.boundary_verdict.digest !== normal.boundary_verdict
-    || evidence.artifacts.control.plan_graph.digest !== normal.plan_graph
-    || evidence.artifacts.shared_state_negative.boundary_manifest.digest
-      !== negative.boundary_manifest
-    || evidence.artifacts.shared_state_negative.boundary_verdict.digest
-      !== negative.boundary_verdict
-    || evidence.artifacts.shared_state_negative.plan_graph.digest !== negative.plan_graph
-    || transformArtifact.source.boundary_manifest_digest !== normal.boundary_manifest
-    || transformArtifact.source.boundary_verdict_digest !== normal.boundary_verdict
-    || transformArtifact.source.control_plan_digest !== normal.plan_graph
-    || transformArtifact.source.query_set_digest !== digestArtifact(querySet)) {
-    fail('query setまたはcontrol artifact digest chainがportable predecessorと一致しない');
-  }
-  if (evidence.sensor.outcomes.length !== querySet.queries.length
-    || evidence.sensor.outcomes.some((outcome, index) => (
-      outcome.id !== querySet.queries[index]?.id
-      || outcome.operation !== querySet.queries[index]?.operation
-      || typeof outcome.result_digest !== 'string'
-      || !SHA256.test(outcome.result_digest)
-    ))
-    || JSON.stringify(evidence.sensor.outcomes.map((outcome) => ({
-      id: outcome.id,
-      operation: outcome.operation,
-      status: outcome.outcome,
-      result_digest: outcome.result_digest,
-    }))) !== JSON.stringify(control.normal.boundary_manifest.graph_evidence)) {
-    fail('portable control evidenceがquery set／control graph evidenceと一致しない');
-  }
-  const transformExecutionEvidenceDigest = assertTransformExecutionEvidence(
-    transformExecutionEvidence,
-    {
-      transformArtifact,
-      transformPatch,
-      controlCompilationEvidence,
-      querySetDigest: digestArtifact(querySet),
-      normal,
-    },
-  );
-  const receipt = transformArtifact.verification.receipts[0];
-  if (transformArtifact.verification.receipts.length !== 1
-    || receipt.id !== VERIFIER.id
-    || receipt.command !== VERIFIER.command
-    || JSON.stringify(receipt.args) !== JSON.stringify(VERIFIER.args)) {
-    fail('accepted transform verifierがRC1 fixed verifierと一致しない');
-  }
-  return {
-    baseSha: transformArtifact.source.base_sha,
-    transformArtifactDigest: digestArtifact(transformArtifact),
-    transformExecutionEvidenceDigest,
-    controlCompilationEvidenceDigest: digestArtifact(controlCompilationEvidence),
-  };
-}
-
-function statusPaths(status) {
-  const fields = status.toString('utf8').split('\0');
-  const paths = [];
-  for (let index = 0; index < fields.length - 1; index += 1) {
-    const entry = fields[index];
-    if (!entry) continue;
-    const code = entry.slice(0, 2);
-    paths.push(entry.slice(3));
-    if (code[0] === 'R' || code[0] === 'C') paths.push(fields[++index]);
-  }
-  return [...new Set(paths)].sort();
-}
-
-function sameArray(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-
-async function assertPatchScope(worktreePath, expectedPaths, { allowSensor = false } = {}) {
-  const status = await run('git', [
-    'status', '--porcelain=v1', '-z', '--untracked-files=all',
-  ], { cwd: worktreePath });
-  const actual = statusPaths(status.stdout);
-  const sensorPrefix = `${INDEX_DIRECTORY}/`;
-  const sensorPaths = actual.filter((entry) => entry.startsWith(sensorPrefix));
-  const sourcePaths = actual.filter((entry) => !entry.startsWith(sensorPrefix));
-  if (!sameArray(sourcePaths, expectedPaths) || (!allowSensor && sensorPaths.length > 0)) {
-    fail(`isolated treatment changed unexpected paths: ${actual.join(',')}`);
-  }
-}
-
-async function observeSnapshot(worktreePath, transformArtifact) {
-  const files = await Promise.all(transformArtifact.output.files.map(async (expected) => {
-    const content = await readFile(path.join(worktreePath, expected.path));
-    const contentDigest = sha256(content);
-    if (contentDigest !== expected.content_digest) {
-      fail(`post-transform file digest drift: ${expected.path}`);
-    }
-    return { path: expected.path, content_digest: contentDigest };
-  }));
-  const snapshotDigest = digestArtifact({ files });
-  if (snapshotDigest !== transformArtifact.output.snapshot_digest) {
-    fail('post-transform snapshot digestがaccepted artifactと一致しない');
-  }
-  return snapshotDigest;
-}
-
-function verifierEnvironment() {
-  const env = { ...process.env, NO_COLOR: '1' };
-  delete env.NODE_TEST_CONTEXT;
-  delete env.FORCE_COLOR;
-  return env;
-}
-
-async function runVerifier(worktreePath) {
-  const result = await run(VERIFIER.command, VERIFIER.args, {
-    cwd: worktreePath,
-    env: verifierEnvironment(),
-  });
-  return {
-    id: VERIFIER.id,
-    command: VERIFIER.command,
-    args: [...VERIFIER.args],
-    outcome: 'passed',
-    exit_code: result.code,
-    stdout_digest: sha256(result.stdout),
-    stderr_digest: sha256(result.stderr),
-  };
-}
-
-function portableStatusSummary(outcome) {
-  const portable = portableSensorOutcome(outcome);
-  const status = portable?.data;
-  if (!status || typeof status !== 'object') fail('portable LatticeSensor statusがない');
-  return {
-    version: status.version,
-    file_count: status.fileCount,
-    node_count: status.nodeCount,
-    edge_count: status.edgeCount,
-    pending_changes: status.pendingChanges,
-    pending_refs: status.index?.pendingRefs,
-    worktree_mismatch: status.worktreeMismatch,
-  };
-}
-
-async function assertSourceUnchanged(repoRoot, expected) {
-  const [head, status, ignoredStatus, worktrees] = await Promise.all([
-    run('git', ['rev-parse', 'HEAD'], { cwd: repoRoot }),
-    run('git', ['status', '--porcelain=v1', '-z'], { cwd: repoRoot }),
-    run('git', [
-      'status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=matching',
-    ], { cwd: repoRoot }),
-    run('git', ['worktree', 'list', '--porcelain'], { cwd: repoRoot }),
-  ]);
-  if (head.stdout.toString('utf8').trim() !== expected.head
-    || !status.stdout.equals(expected.status)
-    || !ignoredStatus.stdout.equals(expected.ignoredStatus)
-    || !worktrees.stdout.equals(expected.worktrees)) {
-    throw new Error('source repository changed during treatment recompile');
-  }
-}
-
-/**
- * accepted seam patchをdisposable worktreeへ適用し、fresh LatticeSensor indexからRC1 plan v2をcompileする。
- * @param {object} options
- * @returns {Promise<{compiled: object, execution: object}>}
- */
-export async function runRc1TreatmentRecompile({
-  repoRoot,
-  planInput,
-  manualNormal,
-  manualNegative,
-  querySet,
-  transformArtifact,
-  transformExecutionEvidence,
-  transformPatch,
-  controlCompilationEvidence,
-  control,
-  execute = executeLatticeSensor,
-} = {}) {
-  const admission = assertAdmission({
-    planInput,
-    manualNormal,
-    manualNegative,
-    querySet,
-    transformArtifact,
-    transformExecutionEvidence,
-    transformPatch,
-    controlCompilationEvidence,
-    control,
-  });
-  if (typeof repoRoot !== 'string' || repoRoot.length === 0 || typeof execute !== 'function') {
-    throw new TypeError('invalid treatment recompile arguments');
-  }
-
-  const [sourceHead, sourceStatus, sourceIgnoredStatus, sourceWorktrees] = await Promise.all([
-    run('git', ['rev-parse', 'HEAD'], { cwd: repoRoot }),
-    run('git', ['status', '--porcelain=v1', '-z'], { cwd: repoRoot }),
-    run('git', [
-      'status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=matching',
-    ], { cwd: repoRoot }),
-    run('git', ['worktree', 'list', '--porcelain'], { cwd: repoRoot }),
-  ]);
-  if (sourceStatus.stdout.length > 0) fail('source repository must be clean');
-  const sourceInvariant = {
-    head: sourceHead.stdout.toString('utf8').trim(),
-    status: sourceStatus.stdout,
-    ignoredStatus: sourceIgnoredStatus.stdout,
-    worktrees: sourceWorktrees.stdout,
-  };
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'lattice-treatment-recompile-'));
-  const worktreePath = path.join(tempRoot, 'worktree');
-  const totalStarted = performance.now();
-  let added = false;
-  let primaryError;
-  let compiled;
-  let verifierReceipt;
-  let rawOutcomesDigest;
-  let portableOutcomesDigest;
-  let sensorSummary;
-  let applyVerifyMs;
-  let indexMs;
-  let compileMs;
-  let sensorCleanup = 'unresolved';
-  let worktreeCleanup = 'unresolved';
-  try {
-    await run('git', ['worktree', 'add', '--detach', worktreePath, admission.baseSha], {
-      cwd: repoRoot,
-    });
-    added = true;
-    const applyStarted = performance.now();
-    await run('git', ['apply', '--check', '--whitespace=error-all', '-'], {
-      cwd: worktreePath,
-      input: transformPatch,
-    });
-    await run('git', ['apply', '--whitespace=error-all', '-'], {
-      cwd: worktreePath,
-      input: transformPatch,
-    });
-    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
-    const codeSnapshotDigest = await observeSnapshot(worktreePath, transformArtifact);
-    verifierReceipt = await runVerifier(worktreePath);
-    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
-    applyVerifyMs = Number((performance.now() - applyStarted).toFixed(3));
-
-    const indexStarted = performance.now();
-    const initialized = await execute({ args: ['init', '.'], cwd: worktreePath });
-    if (initialized?.code !== 0) {
-      throw new Error(`LatticeSensor init failed (${initialized?.code ?? 'unknown'}): ${initialized?.stderr ?? ''}`);
-    }
-    const sensorEvidence = await collectSensorEvidence({
-      cwd: worktreePath,
-      querySet,
-      execute,
-    });
-    indexMs = Number((performance.now() - indexStarted).toFixed(3));
-    rawOutcomesDigest = digestArtifact(sensorEvidence.outcomes);
-    portableOutcomesDigest = digestArtifact(
-      sensorEvidence.outcomes.map(portableSensorOutcome),
-    );
-    sensorSummary = portableStatusSummary(sensorEvidence.outcomes[0]);
-    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths, {
-      allowSensor: true,
-    });
-    await observeSnapshot(worktreePath, transformArtifact);
-
-    const compileStarted = performance.now();
-    compiled = compileTreatmentArtifacts({
-      planInput,
-      manualNormal,
-      manualNegative,
-      querySet,
-      sensorEvidence,
-      codeSnapshotDigest,
-      transformArtifact,
-      control,
-    });
-    compileMs = Number((performance.now() - compileStarted).toFixed(3));
-
-    await rm(path.join(worktreePath, INDEX_DIRECTORY), { recursive: true, force: true });
-    try {
-      await access(path.join(worktreePath, INDEX_DIRECTORY));
-      throw new Error('LatticeSensor sensor state cleanup failed');
-    } catch (error) {
-      if (error.code !== 'ENOENT') throw error;
-    }
-    sensorCleanup = 'passed';
-    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
-  } catch (error) {
-    primaryError = error;
-  }
-
-  let cleanupError;
-  try {
-    if (added) {
-      await run('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repoRoot });
-    }
-    await rm(tempRoot, { recursive: true, force: true });
-    worktreeCleanup = 'passed';
-  } catch (error) {
-    cleanupError = new Error(`treatment worktree cleanup failed: ${error.message}`);
-  }
-  let sourceError;
-  try {
-    await assertSourceUnchanged(repoRoot, sourceInvariant);
-  } catch (error) {
-    sourceError = error;
-  }
-  const errors = [primaryError, cleanupError, sourceError].filter(Boolean);
-  if (errors.length === 1) throw errors[0];
-  if (errors.length > 1) throw new AggregateError(errors, 'treatment recompile failed and cleanup or source invariant also failed');
-
-  return {
-    compiled,
-    execution: {
-      schema: 'lattice.rc1.treatment_recompile_run.v1',
-      base_sha: admission.baseSha,
-      transform_artifact_digest: admission.transformArtifactDigest,
-      transform_execution_evidence_digest: admission.transformExecutionEvidenceDigest,
-      control_compilation_evidence_digest: admission.controlCompilationEvidenceDigest,
-      patch_digest: transformArtifact.patch.digest,
-      query_set_digest: digestArtifact(querySet),
-      code_snapshot_digest: transformArtifact.output.snapshot_digest,
-      graph_digest_projection: PORTABLE_PROJECTION,
-      raw_outcomes_digest: rawOutcomesDigest,
-      portable_outcomes_digest: portableOutcomesDigest,
-      sensor: sensorSummary,
-      verifier: verifierReceipt,
-      timings_ms: {
-        apply_and_verify: applyVerifyMs,
-        fresh_index_and_query: indexMs,
-        compile: compileMs,
-        total: Number((performance.now() - totalStarted).toFixed(3)),
-      },
-      sensor_directory: INDEX_DIRECTORY,
-      sensor_cleanup: sensorCleanup,
-      worktree_cleanup: worktreeCleanup,
-      source_unchanged: true,
-    },
-  };
-}
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import {
+  access,
+  mkdtemp,
+  readFile,
+  rm,
+} from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+import {
+  canonicalizeArtifact,
+  digestArtifact,
+  validateTransformArtifact,
+} from './artifact-contracts.mjs';
+import {
+  collectSensorEvidence,
+  portableSensorOutcome,
+} from './sensor-adapter.mjs';
+import { spawnSensorCli } from './sensor-runtime.mjs';
+import { compileTreatmentArtifacts } from './treatment-compiler.mjs';
+
+const SHA1 = /^[0-9a-f]{40}$/;
+const SHA256 = /^[0-9a-f]{64}$/;
+const PORTABLE_PROJECTION = 'lattice.sensor_portable_outcome.v1';
+const VERIFIER = Object.freeze({
+  id: 'dispatch-characterization',
+  command: 'node',
+  args: ['--test', '--test-reporter=dot', 'test/research-dispatch-record.test.mjs'],
+});
+
+function fail(reason) {
+  throw new TypeError(`treatment recompile契約違反: ${reason}`);
+}
+
+function exactRecord(value, keys) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)
+    || Object.getPrototypeOf(value) !== Object.prototype) {
+    return false;
+  }
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length
+    && actual.every((key, index) => key === expected[index]);
+}
+
+function sha256(value) {
+  return createHash('sha256').update(value).digest('hex');
+}
+
+function run(command, args, { cwd, env, input, allowExitCodes = [0] } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      shell: false,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on('data', (chunk) => stdout.push(chunk));
+    child.stderr.on('data', (chunk) => stderr.push(chunk));
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      const result = {
+        code,
+        signal,
+        stdout: Buffer.concat(stdout),
+        stderr: Buffer.concat(stderr),
+      };
+      if (allowExitCodes.includes(code) && signal === null) resolve(result);
+      else reject(Object.assign(
+        new Error(`${command} failed (${signal ?? code}): ${result.stderr.toString('utf8').trim()}`),
+        result,
+      ));
+    });
+    child.stdin.end(input);
+  });
+}
+
+function sensorEnvironment() {
+  const env = {
+    ...process.env,
+    LATTICE_SENSOR_NO_DAEMON: '1',
+    LATTICE_SENSOR_NO_WATCH: '1',
+    LATTICE_SENSOR_NO_UPDATE_CHECK: '1',
+    DO_NOT_TRACK: '1',
+    NO_COLOR: '1',
+  };
+  delete env.FORCE_COLOR;
+  return env;
+}
+
+function executeLatticeSensor({ args, cwd }) {
+  return new Promise((resolve) => {
+    const child = spawnSensorCli(args, {
+      cwd,
+      env: sensorEnvironment(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('error', (error) => {
+      resolve({ code: null, stdout, stderr, error: error.message });
+    });
+    child.once('close', (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+function artifactMeta(value) {
+  return exactRecord(value, ['digest', 'canonical_bytes'])
+    && typeof value.digest === 'string'
+    && SHA256.test(value.digest)
+    && Number.isSafeInteger(value.canonical_bytes)
+    && value.canonical_bytes > 0;
+}
+
+function artifactSet(value) {
+  return exactRecord(value, ['boundary_manifest', 'boundary_verdict', 'plan_graph'])
+    && Object.values(value).every(artifactMeta);
+}
+
+function assertPortableControlEvidence(evidence) {
+  if (!exactRecord(evidence, [
+    'schema',
+    'observed_at',
+    'head',
+    'executor_head',
+    'graph_digest_projection',
+    'input_digests',
+    'sensor',
+    'artifacts',
+    'observed_facts',
+    'presentation_note',
+  ])
+    || evidence.schema !== 'lattice.rc1.control_compilation_evidence.v2'
+    || evidence.graph_digest_projection !== PORTABLE_PROJECTION) {
+    fail('portable control evidence v2だけがrecompileへ進める');
+  }
+  if (typeof evidence.head !== 'string'
+    || !SHA1.test(evidence.head)
+    || typeof evidence.executor_head !== 'string'
+    || !SHA1.test(evidence.executor_head)
+    || !exactRecord(evidence.input_digests, [
+      'plan_input',
+      'query_set',
+      'manual_normal',
+      'manual_shared_state_negative',
+      'code_snapshot',
+    ])
+    || Object.values(evidence.input_digests).some((digest) => (
+      typeof digest !== 'string' || !SHA256.test(digest)
+    ))
+    || !exactRecord(evidence.artifacts, ['control', 'shared_state_negative'])
+    || !artifactSet(evidence.artifacts.control)
+    || !artifactSet(evidence.artifacts.shared_state_negative)
+    || !exactRecord(evidence.sensor, [
+      'version',
+      'file_count',
+      'node_count',
+      'edge_count',
+      'pending_changes',
+      'pending_refs',
+      'worktree_mismatch',
+      'fresh_index_repetitions',
+      'raw_outcomes_digests',
+      'raw_outcomes_equal',
+      'portable_outcomes_digest',
+      'portable_outcomes_equal',
+      'outcomes',
+    ])
+    || evidence.sensor.fresh_index_repetitions !== 2
+    || !Array.isArray(evidence.sensor.raw_outcomes_digests)
+    || evidence.sensor.raw_outcomes_digests.length !== 2
+    || evidence.sensor.raw_outcomes_digests.some((digest) => (
+      typeof digest !== 'string' || !SHA256.test(digest)
+    ))
+    || new Set(evidence.sensor.raw_outcomes_digests).size !== 2
+    || evidence.sensor.raw_outcomes_equal !== false
+    || typeof evidence.sensor.portable_outcomes_digest !== 'string'
+    || !SHA256.test(evidence.sensor.portable_outcomes_digest)
+    || evidence.sensor.portable_outcomes_equal !== true
+    || !Array.isArray(evidence.sensor.outcomes)
+    || evidence.sensor.outcomes.length === 0) {
+    fail('portable control evidence v2のdigest metadataが不正');
+  }
+}
+
+function assertTransformExecutionEvidence(evidence, {
+  transformArtifact,
+  transformPatch,
+  controlCompilationEvidence,
+  querySetDigest,
+  normal,
+}) {
+  if (!exactRecord(evidence, [
+    'schema',
+    'observed_at',
+    'executor_head',
+    'experiment_base_sha',
+    'control_compilation_evidence_schema',
+    'graph_digest_projection',
+    'input_digests',
+    'runs',
+    'artifacts',
+    'observed_facts',
+    'presentation_note',
+  ])
+    || evidence.schema !== 'lattice.rc1.seam_transform_execution_evidence.v2'
+    || typeof evidence.executor_head !== 'string'
+    || !SHA1.test(evidence.executor_head)
+    || evidence.experiment_base_sha !== transformArtifact.source.base_sha
+    || evidence.control_compilation_evidence_schema !== controlCompilationEvidence.schema
+    || evidence.graph_digest_projection !== PORTABLE_PROJECTION
+    || !exactRecord(evidence.input_digests, [
+      'boundary_manifest',
+      'boundary_verdict',
+      'control_plan',
+      'query_set',
+      'control_compilation_evidence',
+    ])
+    || !exactRecord(evidence.runs, [
+      'accepted_primary',
+      'accepted_repeat',
+      'scope_rejection',
+      'behavior_rejection',
+    ])
+    || !exactRecord(evidence.artifacts, [
+      'transform',
+      'scope_rejection',
+      'behavior_rejection',
+      'patch',
+    ])
+    || !artifactMeta(evidence.artifacts.transform)
+    || !artifactMeta(evidence.artifacts.scope_rejection)
+    || !artifactMeta(evidence.artifacts.behavior_rejection)
+    || !exactRecord(evidence.artifacts.patch, ['digest', 'bytes'])) {
+    fail('transform execution evidence v2が不正');
+  }
+  const transformArtifactDigest = digestArtifact(transformArtifact);
+  const transformCanonicalBytes = Buffer.byteLength(canonicalizeArtifact(transformArtifact));
+  if (evidence.input_digests.boundary_manifest !== normal.boundary_manifest
+    || evidence.input_digests.boundary_verdict !== normal.boundary_verdict
+    || evidence.input_digests.control_plan !== normal.plan_graph
+    || evidence.input_digests.query_set !== querySetDigest
+    || evidence.input_digests.control_compilation_evidence
+      !== digestArtifact(controlCompilationEvidence)
+    || evidence.runs.accepted_primary?.artifact_digest !== transformArtifactDigest
+    || evidence.runs.accepted_repeat?.artifact_digest !== transformArtifactDigest
+    || evidence.artifacts.transform.digest !== transformArtifactDigest
+    || evidence.artifacts.transform.canonical_bytes !== transformCanonicalBytes
+    || evidence.artifacts.patch.digest !== sha256(transformPatch)
+    || evidence.artifacts.patch.bytes !== transformPatch.byteLength
+    || evidence.observed_facts?.deterministic_repeat !== true
+    || evidence.observed_facts?.same_control_base !== true
+    || evidence.observed_facts?.portable_control_chain !== true
+    || evidence.observed_facts?.characterization_passed !== true
+    || evidence.observed_facts?.git_apply_check !== 'passed'
+    || evidence.observed_facts?.source_unchanged !== true
+    || evidence.observed_facts?.cleanup !== 'passed') {
+    fail('transform execution evidenceのpredecessor chainが一致しない');
+  }
+  return digestArtifact(evidence);
+}
+
+function bundleDigests(bundle) {
+  if (!exactRecord(bundle, ['boundary_manifest', 'boundary_verdict', 'plan_graph'])) {
+    fail('control artifact setが不正');
+  }
+  return {
+    boundary_manifest: digestArtifact(bundle.boundary_manifest),
+    boundary_verdict: digestArtifact(bundle.boundary_verdict),
+    plan_graph: digestArtifact(bundle.plan_graph),
+  };
+}
+
+function assertAdmission({
+  planInput,
+  manualNormal,
+  manualNegative,
+  querySet,
+  transformArtifact,
+  transformExecutionEvidence,
+  transformPatch,
+  controlCompilationEvidence,
+  control,
+}) {
+  for (const value of [
+    planInput,
+    manualNormal,
+    manualNegative,
+    querySet,
+    transformArtifact,
+    transformExecutionEvidence,
+    controlCompilationEvidence,
+    control,
+  ]) {
+    canonicalizeArtifact(value);
+  }
+  if (!validateTransformArtifact(transformArtifact) || transformArtifact.status !== 'accepted') {
+    fail('accepted transform artifactが必要');
+  }
+  if (!Buffer.isBuffer(transformPatch)
+    || sha256(transformPatch) !== transformArtifact.patch.digest
+    || transformPatch.byteLength !== transformArtifact.patch.bytes) {
+    fail('transform patch digestまたはpatch bytesがartifactと一致しない');
+  }
+  assertPortableControlEvidence(controlCompilationEvidence);
+  if (!exactRecord(control, ['normal', 'negative'])) fail('control artifact setが不正');
+  const normal = bundleDigests(control.normal);
+  const negative = bundleDigests(control.negative);
+  const evidence = controlCompilationEvidence;
+  if (evidence.head !== transformArtifact.source.base_sha
+    || evidence.input_digests.plan_input !== digestArtifact(planInput)
+    || evidence.input_digests.query_set !== digestArtifact(querySet)
+    || evidence.input_digests.manual_normal !== digestArtifact(manualNormal)
+    || evidence.input_digests.manual_shared_state_negative !== digestArtifact(manualNegative)
+    || evidence.input_digests.code_snapshot !== transformArtifact.source.code_snapshot_digest
+    || evidence.artifacts.control.boundary_manifest.digest !== normal.boundary_manifest
+    || evidence.artifacts.control.boundary_verdict.digest !== normal.boundary_verdict
+    || evidence.artifacts.control.plan_graph.digest !== normal.plan_graph
+    || evidence.artifacts.shared_state_negative.boundary_manifest.digest
+      !== negative.boundary_manifest
+    || evidence.artifacts.shared_state_negative.boundary_verdict.digest
+      !== negative.boundary_verdict
+    || evidence.artifacts.shared_state_negative.plan_graph.digest !== negative.plan_graph
+    || transformArtifact.source.boundary_manifest_digest !== normal.boundary_manifest
+    || transformArtifact.source.boundary_verdict_digest !== normal.boundary_verdict
+    || transformArtifact.source.control_plan_digest !== normal.plan_graph
+    || transformArtifact.source.query_set_digest !== digestArtifact(querySet)) {
+    fail('query setまたはcontrol artifact digest chainがportable predecessorと一致しない');
+  }
+  if (evidence.sensor.outcomes.length !== querySet.queries.length
+    || evidence.sensor.outcomes.some((outcome, index) => (
+      outcome.id !== querySet.queries[index]?.id
+      || outcome.operation !== querySet.queries[index]?.operation
+      || typeof outcome.result_digest !== 'string'
+      || !SHA256.test(outcome.result_digest)
+    ))
+    || JSON.stringify(evidence.sensor.outcomes.map((outcome) => ({
+      id: outcome.id,
+      operation: outcome.operation,
+      status: outcome.outcome,
+      result_digest: outcome.result_digest,
+    }))) !== JSON.stringify(control.normal.boundary_manifest.graph_evidence)) {
+    fail('portable control evidenceがquery set／control graph evidenceと一致しない');
+  }
+  const transformExecutionEvidenceDigest = assertTransformExecutionEvidence(
+    transformExecutionEvidence,
+    {
+      transformArtifact,
+      transformPatch,
+      controlCompilationEvidence,
+      querySetDigest: digestArtifact(querySet),
+      normal,
+    },
+  );
+  const receipt = transformArtifact.verification.receipts[0];
+  if (transformArtifact.verification.receipts.length !== 1
+    || receipt.id !== VERIFIER.id
+    || receipt.command !== VERIFIER.command
+    || JSON.stringify(receipt.args) !== JSON.stringify(VERIFIER.args)) {
+    fail('accepted transform verifierがRC1 fixed verifierと一致しない');
+  }
+  return {
+    baseSha: transformArtifact.source.base_sha,
+    transformArtifactDigest: digestArtifact(transformArtifact),
+    transformExecutionEvidenceDigest,
+    controlCompilationEvidenceDigest: digestArtifact(controlCompilationEvidence),
+  };
+}
+
+function statusPaths(status) {
+  const fields = status.toString('utf8').split('\0');
+  const paths = [];
+  for (let index = 0; index < fields.length - 1; index += 1) {
+    const entry = fields[index];
+    if (!entry) continue;
+    const code = entry.slice(0, 2);
+    paths.push(entry.slice(3));
+    if (code[0] === 'R' || code[0] === 'C') paths.push(fields[++index]);
+  }
+  return [...new Set(paths)].sort();
+}
+
+function sameArray(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+async function assertPatchScope(worktreePath, expectedPaths, { allowSensor = false } = {}) {
+  const status = await run('git', [
+    'status', '--porcelain=v1', '-z', '--untracked-files=all',
+  ], { cwd: worktreePath });
+  const actual = statusPaths(status.stdout);
+  const sensorPrefix = `${INDEX_DIRECTORY}/`;
+  const sensorPaths = actual.filter((entry) => entry.startsWith(sensorPrefix));
+  const sourcePaths = actual.filter((entry) => !entry.startsWith(sensorPrefix));
+  if (!sameArray(sourcePaths, expectedPaths) || (!allowSensor && sensorPaths.length > 0)) {
+    fail(`isolated treatment changed unexpected paths: ${actual.join(',')}`);
+  }
+}
+
+async function observeSnapshot(worktreePath, transformArtifact) {
+  const files = await Promise.all(transformArtifact.output.files.map(async (expected) => {
+    const content = await readFile(path.join(worktreePath, expected.path));
+    const contentDigest = sha256(content);
+    if (contentDigest !== expected.content_digest) {
+      fail(`post-transform file digest drift: ${expected.path}`);
+    }
+    return { path: expected.path, content_digest: contentDigest };
+  }));
+  const snapshotDigest = digestArtifact({ files });
+  if (snapshotDigest !== transformArtifact.output.snapshot_digest) {
+    fail('post-transform snapshot digestがaccepted artifactと一致しない');
+  }
+  return snapshotDigest;
+}
+
+function verifierEnvironment() {
+  const env = { ...process.env, NO_COLOR: '1' };
+  delete env.NODE_TEST_CONTEXT;
+  delete env.FORCE_COLOR;
+  return env;
+}
+
+async function runVerifier(worktreePath) {
+  const result = await run(VERIFIER.command, VERIFIER.args, {
+    cwd: worktreePath,
+    env: verifierEnvironment(),
+  });
+  return {
+    id: VERIFIER.id,
+    command: VERIFIER.command,
+    args: [...VERIFIER.args],
+    outcome: 'passed',
+    exit_code: result.code,
+    stdout_digest: sha256(result.stdout),
+    stderr_digest: sha256(result.stderr),
+  };
+}
+
+function portableStatusSummary(outcome) {
+  const portable = portableSensorOutcome(outcome);
+  const status = portable?.data;
+  if (!status || typeof status !== 'object') fail('portable LatticeSensor statusがない');
+  return {
+    version: status.version,
+    file_count: status.fileCount,
+    node_count: status.nodeCount,
+    edge_count: status.edgeCount,
+    pending_changes: status.pendingChanges,
+    pending_refs: status.index?.pendingRefs,
+    worktree_mismatch: status.worktreeMismatch,
+  };
+}
+
+async function assertSourceUnchanged(repoRoot, expected) {
+  const [head, status, ignoredStatus, worktrees] = await Promise.all([
+    run('git', ['rev-parse', 'HEAD'], { cwd: repoRoot }),
+    run('git', ['status', '--porcelain=v1', '-z'], { cwd: repoRoot }),
+    run('git', [
+      'status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=matching',
+    ], { cwd: repoRoot }),
+    run('git', ['worktree', 'list', '--porcelain'], { cwd: repoRoot }),
+  ]);
+  if (head.stdout.toString('utf8').trim() !== expected.head
+    || !status.stdout.equals(expected.status)
+    || !ignoredStatus.stdout.equals(expected.ignoredStatus)
+    || !worktrees.stdout.equals(expected.worktrees)) {
+    throw new Error('source repository changed during treatment recompile');
+  }
+}
+
+/**
+ * accepted seam patchをdisposable worktreeへ適用し、fresh LatticeSensor indexからRC1 plan v2をcompileする。
+ * @param {object} options
+ * @returns {Promise<{compiled: object, execution: object}>}
+ */
+export async function runRc1TreatmentRecompile({
+  repoRoot,
+  planInput,
+  manualNormal,
+  manualNegative,
+  querySet,
+  transformArtifact,
+  transformExecutionEvidence,
+  transformPatch,
+  controlCompilationEvidence,
+  control,
+  execute = executeLatticeSensor,
+} = {}) {
+  const admission = assertAdmission({
+    planInput,
+    manualNormal,
+    manualNegative,
+    querySet,
+    transformArtifact,
+    transformExecutionEvidence,
+    transformPatch,
+    controlCompilationEvidence,
+    control,
+  });
+  if (typeof repoRoot !== 'string' || repoRoot.length === 0 || typeof execute !== 'function') {
+    throw new TypeError('invalid treatment recompile arguments');
+  }
+
+  const [sourceHead, sourceStatus, sourceIgnoredStatus, sourceWorktrees] = await Promise.all([
+    run('git', ['rev-parse', 'HEAD'], { cwd: repoRoot }),
+    run('git', ['status', '--porcelain=v1', '-z'], { cwd: repoRoot }),
+    run('git', [
+      'status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=matching',
+    ], { cwd: repoRoot }),
+    run('git', ['worktree', 'list', '--porcelain'], { cwd: repoRoot }),
+  ]);
+  if (sourceStatus.stdout.length > 0) fail('source repository must be clean');
+  const sourceInvariant = {
+    head: sourceHead.stdout.toString('utf8').trim(),
+    status: sourceStatus.stdout,
+    ignoredStatus: sourceIgnoredStatus.stdout,
+    worktrees: sourceWorktrees.stdout,
+  };
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'lattice-treatment-recompile-'));
+  const worktreePath = path.join(tempRoot, 'worktree');
+  const totalStarted = performance.now();
+  let added = false;
+  let primaryError;
+  let compiled;
+  let verifierReceipt;
+  let rawOutcomesDigest;
+  let portableOutcomesDigest;
+  let sensorSummary;
+  let applyVerifyMs;
+  let indexMs;
+  let compileMs;
+  let sensorCleanup = 'unresolved';
+  let worktreeCleanup = 'unresolved';
+  try {
+    await run('git', ['worktree', 'add', '--detach', worktreePath, admission.baseSha], {
+      cwd: repoRoot,
+    });
+    added = true;
+    const applyStarted = performance.now();
+    await run('git', ['apply', '--check', '--whitespace=error-all', '-'], {
+      cwd: worktreePath,
+      input: transformPatch,
+    });
+    await run('git', ['apply', '--whitespace=error-all', '-'], {
+      cwd: worktreePath,
+      input: transformPatch,
+    });
+    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
+    const codeSnapshotDigest = await observeSnapshot(worktreePath, transformArtifact);
+    verifierReceipt = await runVerifier(worktreePath);
+    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
+    applyVerifyMs = Number((performance.now() - applyStarted).toFixed(3));
+
+    const indexStarted = performance.now();
+    const initialized = await execute({ args: ['init', '.'], cwd: worktreePath });
+    if (initialized?.code !== 0) {
+      throw new Error(`LatticeSensor init failed (${initialized?.code ?? 'unknown'}): ${initialized?.stderr ?? ''}`);
+    }
+    const sensorEvidence = await collectSensorEvidence({
+      cwd: worktreePath,
+      querySet,
+      execute,
+    });
+    indexMs = Number((performance.now() - indexStarted).toFixed(3));
+    rawOutcomesDigest = digestArtifact(sensorEvidence.outcomes);
+    portableOutcomesDigest = digestArtifact(
+      sensorEvidence.outcomes.map(portableSensorOutcome),
+    );
+    sensorSummary = portableStatusSummary(sensorEvidence.outcomes[0]);
+    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths, {
+      allowSensor: true,
+    });
+    await observeSnapshot(worktreePath, transformArtifact);
+
+    const compileStarted = performance.now();
+    compiled = compileTreatmentArtifacts({
+      planInput,
+      manualNormal,
+      manualNegative,
+      querySet,
+      sensorEvidence,
+      codeSnapshotDigest,
+      transformArtifact,
+      control,
+    });
+    compileMs = Number((performance.now() - compileStarted).toFixed(3));
+
+    await rm(path.join(worktreePath, INDEX_DIRECTORY), { recursive: true, force: true });
+    try {
+      await access(path.join(worktreePath, INDEX_DIRECTORY));
+      throw new Error('LatticeSensor sensor state cleanup failed');
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+    sensorCleanup = 'passed';
+    await assertPatchScope(worktreePath, transformArtifact.scope.changed_paths);
+  } catch (error) {
+    primaryError = error;
+  }
+
+  let cleanupError;
+  try {
+    if (added) {
+      await run('git', ['worktree', 'remove', '--force', worktreePath], { cwd: repoRoot });
+    }
+    await rm(tempRoot, { recursive: true, force: true });
+    worktreeCleanup = 'passed';
+  } catch (error) {
+    cleanupError = new Error(`treatment worktree cleanup failed: ${error.message}`);
+  }
+  let sourceError;
+  try {
+    await assertSourceUnchanged(repoRoot, sourceInvariant);
+  } catch (error) {
+    sourceError = error;
+  }
+  const errors = [primaryError, cleanupError, sourceError].filter(Boolean);
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) throw new AggregateError(errors, 'treatment recompile failed and cleanup or source invariant also failed');
+
+  return {
+    compiled,
+    execution: {
+      schema: 'lattice.rc1.treatment_recompile_run.v1',
+      base_sha: admission.baseSha,
+      transform_artifact_digest: admission.transformArtifactDigest,
+      transform_execution_evidence_digest: admission.transformExecutionEvidenceDigest,
+      control_compilation_evidence_digest: admission.controlCompilationEvidenceDigest,
+      patch_digest: transformArtifact.patch.digest,
+      query_set_digest: digestArtifact(querySet),
+      code_snapshot_digest: transformArtifact.output.snapshot_digest,
+      graph_digest_projection: PORTABLE_PROJECTION,
+      raw_outcomes_digest: rawOutcomesDigest,
+      portable_outcomes_digest: portableOutcomesDigest,
+      sensor: sensorSummary,
+      verifier: verifierReceipt,
+      timings_ms: {
+        apply_and_verify: applyVerifyMs,
+        fresh_index_and_query: indexMs,
+        compile: compileMs,
+        total: Number((performance.now() - totalStarted).toFixed(3)),
+      },
+      sensor_directory: INDEX_DIRECTORY,
+      sensor_cleanup: sensorCleanup,
+      worktree_cleanup: worktreeCleanup,
+      source_unchanged: true,
+    },
+  };
+}