@quolu/lattice 0.52.0 → 0.52.2

package/src/boundary-compiler.mjs

@@ -1,712 +1,712 @@
-import {
-  canonicalizeArtifact,
-  digestArtifact,
-  validateBoundaryManifest,
-  validateBoundaryVerdict,
-  validatePlanGraph,
-  validatePlanInput,
-} from './artifact-contracts.mjs';
-import { portableSensorOutcome } from './sensor-adapter.mjs';
-
-const SHA256 = /^[0-9a-f]{64}$/;
-const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
-const OPERATIONS = new Set(['status', 'query', 'callers', 'callees', 'impact', 'affected']);
-const OPTION_KEYS = [
-  'candidateSpec',
-  'codeSnapshotDigest',
-  'sensorEvidence',
-  'manualEvidence',
-  'planInput',
-  'planVersion',
-  'querySet',
-];
-
-export const RC1_BOUNDARY_COMPILER_CONTRACT = Object.freeze({
-  export_name: 'compileBoundaryCondition',
-  condition_selector: 'forbidden',
-  surface_resolution: 'exact_graph_name_or_qualified_name_at_expected_path',
-  conflict_rule: 'pairwise_write_resource_intersection',
-});
-
-function fail(reason) {
-  throw new TypeError(`RC1 v4 boundary compiler契約違反: ${reason}`);
-}
-
-function isPlainObject(value) {
-  return value !== null
-    && typeof value === 'object'
-    && !Array.isArray(value)
-    && Object.getPrototypeOf(value) === Object.prototype;
-}
-
-function exactRecord(value, keys) {
-  if (!isPlainObject(value)) 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 nonEmptyText(value) {
-  return typeof value === 'string' && value.length > 0 && value.length <= 4_096;
-}
-
-function identifier(value) {
-  return typeof value === 'string' && IDENTIFIER.test(value);
-}
-
-function repoPath(value) {
-  return typeof value === 'string'
-    && value.length > 0
-    && value.length <= 1_024
-    && !value.includes('\0')
-    && !value.startsWith('/')
-    && !value.split('/').includes('..');
-}
-
-function unique(values) {
-  return [...new Set(values)];
-}
-
-function resourceKey(value) {
-  return `${value.kind}\0${value.target}`;
-}
-
-function uniqueResources(values) {
-  return [...new Map(values.map((value) => [resourceKey(value), value])).values()]
-    .sort((left, right) => resourceKey(left).localeCompare(resourceKey(right)));
-}
-
-function assertManualEvidence(planInput, manualEvidence) {
-  if (!exactRecord(manualEvidence, ['schema', 'evidence'])
-    || manualEvidence.schema !== 'lattice.manual_boundary_evidence.v1'
-    || !Array.isArray(manualEvidence.evidence)
-    || manualEvidence.evidence.length !== planInput.todos.length) {
-    fail('manual evidence rootがplan inputと一致しない');
-  }
-  const todoIds = planInput.todos.map(({ id }) => id);
-  if (new Set(manualEvidence.evidence.map(({ todo_id: todoId }) => todoId)).size !== todoIds.length) {
-    fail('manual evidence todo IDが一意でない');
-  }
-  for (const entry of manualEvidence.evidence) {
-    if (!exactRecord(entry, ['todo_id', 'state_reads', 'state_writes', 'effects', 'unknowns'])
-      || !todoIds.includes(entry.todo_id)
-      || ![entry.state_reads, entry.state_writes, entry.effects, entry.unknowns]
-        .every((values) => Array.isArray(values)
-          && values.every(nonEmptyText)
-          && new Set(values).size === values.length)) {
-      fail('manual evidence recordが不正');
-    }
-  }
-}
-
-function assertTestSurface(value, { proposed }) {
-  if (!exactRecord(value, [
-    'symbol',
-    'path',
-    'query_id',
-    'impact_id',
-    'assertion_id',
-    'provenance',
-  ])
-    || (proposed ? !nonEmptyText(value.symbol) : value.symbol !== null)
-    || !repoPath(value.path)
-    || !identifier(value.query_id)
-    || (proposed ? !identifier(value.impact_id) : value.impact_id !== null)
-    || !identifier(value.assertion_id)
-    || !exactRecord(value.provenance, ['kind', 'ref'])
-    || value.provenance.kind !== 'todo_outcome'
-    || !nonEmptyText(value.provenance.ref)) {
-    fail(`${proposed ? 'proposed' : 'current'} test surfaceが不正`);
-  }
-}
-
-function assertProductionSurface(value) {
-  if (!exactRecord(value, ['symbol', 'path', 'query_id', 'impact_id', 'link_query_id'])
-    || !nonEmptyText(value.symbol)
-    || !repoPath(value.path)
-    || !identifier(value.query_id)
-    || !identifier(value.impact_id)
-    || !identifier(value.link_query_id)) {
-    fail('production surfaceが不正');
-  }
-}
-
-function assertCandidateSpec(planInput, candidateSpec) {
-  if (!exactRecord(candidateSpec, [
-    'schema',
-    'candidate_id',
-    'plan_input_ref',
-    'query_set_ref',
-    'behavior_oracle_ref',
-    'compiler_contract',
-    'stable_surfaces',
-    'todos',
-  ])
-    || candidateSpec.schema !== 'lattice.rc1.boundary_candidate_spec.v2'
-    || !identifier(candidateSpec.candidate_id)
-    || !repoPath(candidateSpec.plan_input_ref)
-    || !repoPath(candidateSpec.query_set_ref)
-    || !repoPath(candidateSpec.behavior_oracle_ref)
-    || !exactRecord(candidateSpec.compiler_contract, [
-      'condition_selector',
-      'surface_resolution',
-      'proposed_activation',
-      'unresolved_policy',
-      'conflict_rule',
-    ])
-    || candidateSpec.compiler_contract.condition_selector !== 'forbidden'
-    || candidateSpec.compiler_contract.surface_resolution
-      !== 'exact_graph_name_or_qualified_name_at_expected_path'
-    || candidateSpec.compiler_contract.proposed_activation
-      !== 'all_proposed_production_and_test_surfaces_exact'
-    || candidateSpec.compiler_contract.unresolved_policy !== 'typed_unknown'
-    || candidateSpec.compiler_contract.conflict_rule !== 'pairwise_write_resource_intersection'
-    || !Array.isArray(candidateSpec.stable_surfaces)
-    || candidateSpec.stable_surfaces.length === 0
-    || !Array.isArray(candidateSpec.todos)
-    || candidateSpec.todos.length !== planInput.todos.length) {
-    fail('candidate spec rootが不正');
-  }
-
-  for (const surface of candidateSpec.stable_surfaces) {
-    if (!exactRecord(surface, ['kind', 'target', 'path', 'role', 'active_when'])
-      || !new Set(['symbol', 'path']).has(surface.kind)
-      || !nonEmptyText(surface.target)
-      || !repoPath(surface.path)
-      || !identifier(surface.role)
-      || !new Set(['always', 'proposed']).has(surface.active_when)) {
-      fail('stable surfaceが不正');
-    }
-  }
-
-  const planTodos = new Map(planInput.todos.map((todo) => [todo.id, todo]));
-  for (const todo of candidateSpec.todos) {
-    if (!exactRecord(todo, ['todo_id', 'outcome', 'current', 'proposed'])
-      || !planTodos.has(todo.todo_id)
-      || todo.outcome !== planTodos.get(todo.todo_id).outcome) {
-      fail('candidate TODOがplan inputと一致しない');
-    }
-    for (const [mode, proposed] of [['current', false], ['proposed', true]]) {
-      const value = todo[mode];
-      if (!exactRecord(value, ['production', 'tests'])
-        || !Array.isArray(value.tests)
-        || value.tests.length === 0) {
-        fail(`${mode} surface setが不正`);
-      }
-      assertProductionSurface(value.production);
-      for (const test of value.tests) assertTestSurface(test, { proposed });
-    }
-  }
-  if (new Set(candidateSpec.todos.map(({ todo_id: todoId }) => todoId)).size
-    !== planInput.todos.length) {
-    fail('candidate TODO IDが一意でない');
-  }
-}
-
-function assertQuerySet(querySet, candidateSpec) {
-  if (!exactRecord(querySet, ['schema', 'queries'])
-    || querySet.schema !== 'lattice.sensor_query_set.v2'
-    || !Array.isArray(querySet.queries)
-    || querySet.queries.length === 0
-    || querySet.queries.length > 256) {
-    fail('query set rootが不正');
-  }
-  const ids = new Set();
-  for (const query of querySet.queries) {
-    if (!isPlainObject(query) || !identifier(query.id) || ids.has(query.id)
-      || !OPERATIONS.has(query.operation)) {
-      fail('query set recordが不正');
-    }
-    ids.add(query.id);
-    if (query.operation === 'status') {
-      if (!exactRecord(query, ['id', 'operation'])) fail('status query shapeが不正');
-    } else if (query.operation === 'affected') {
-      if (!exactRecord(query, ['id', 'operation', 'targets'])
-        || !Array.isArray(query.targets)
-        || query.targets.length === 0
-        || !query.targets.every(repoPath)
-        || new Set(query.targets).size !== query.targets.length) {
-        fail('affected query shapeが不正');
-      }
-    } else if (!exactRecord(query, ['id', 'operation', 'target'])
-      || !nonEmptyText(query.target)) {
-      fail('graph query shapeが不正');
-    }
-  }
-  if (querySet.queries.filter(({ operation }) => operation === 'status').length !== 1
-    || querySet.queries.filter(({ operation }) => operation === 'affected').length !== 1) {
-    fail('query setにstatusとaffectedがexactly one必要');
-  }
-
-  const referenced = candidateSpec.todos.flatMap((todo) => [todo.current, todo.proposed]
-    .flatMap((surface) => [
-      surface.production.query_id,
-      surface.production.impact_id,
-      surface.production.link_query_id,
-      ...surface.tests.flatMap((entry) => [entry.query_id, entry.impact_id].filter(Boolean)),
-    ]));
-  if (referenced.some((id) => !ids.has(id))) {
-    fail('candidate specがquery set外のIDを参照する');
-  }
-}
-
-function assertLatticeSensorEvidence(querySet, sensorEvidence) {
-  if (!isPlainObject(sensorEvidence)
-    || !Array.isArray(sensorEvidence.outcomes)
-    || sensorEvidence.outcomes.length !== querySet.queries.length) {
-    fail('LatticeSensor evidence rootがquery setと一致しない');
-  }
-  for (let index = 0; index < querySet.queries.length; index += 1) {
-    const query = querySet.queries[index];
-    const outcome = sensorEvidence.outcomes[index];
-    if (!isPlainObject(outcome)
-      || outcome.id !== query.id
-      || outcome.operation !== query.operation
-      || !nonEmptyText(outcome.outcome)) {
-      fail(`LatticeSensor evidence ${query.id}がID／operation／順序と一致しない`);
-    }
-    if (query.operation !== 'status' && query.operation !== 'affected'
-      && outcome.target !== query.target) {
-      fail(`LatticeSensor evidence ${query.id}のtargetがquery setと一致しない`);
-    }
-    if (query.operation === 'affected'
-      && (!Array.isArray(outcome.targets)
-        || outcome.targets.length !== query.targets.length
-        || outcome.targets.some((entry, targetIndex) => (
-          !isPlainObject(entry) || entry.target !== query.targets[targetIndex]
-        )))) {
-      fail(`LatticeSensor evidence ${query.id}のaffected targetがquery setと一致しない`);
-    }
-  }
-}
-
-function exactNodeAt(records, target, expectedPath) {
-  if (!Array.isArray(records)) return false;
-  const exact = records.filter((entry) => isPlainObject(entry?.node)
-    && (entry.node.name === target || entry.node.qualifiedName === target)
-    && entry.node.filePath === expectedPath);
-  return exact.length === 1;
-}
-
-function exactQueryStatus(outcome, target, expectedPath) {
-  if (outcome?.outcome === 'symbol_absent') return 'absent';
-  if (outcome?.outcome !== 'ready') return 'unknown';
-  return exactNodeAt(outcome.data, target, expectedPath) ? 'ready' : 'unknown';
-}
-
-function exactResolutionStatus(outcome, target, expectedPath) {
-  if (outcome?.outcome === 'symbol_absent') return 'absent';
-  if (outcome?.outcome !== 'ready') return 'unknown';
-  return exactNodeAt(outcome.resolution, target, expectedPath) ? 'ready' : 'unknown';
-}
-
-function callerLinkStatus(outcome, production, anchor) {
-  const resolution = exactResolutionStatus(outcome, production.symbol, production.path);
-  if (resolution !== 'ready') return resolution;
-  const callers = outcome.data?.callers;
-  if (!Array.isArray(callers)) return 'unknown';
-  return callers.some((entry) => entry?.name === anchor.symbol && entry?.filePath === anchor.path)
-    ? 'ready'
-    : 'unknown';
-}
-
-function outcomeMap(querySet, sensorEvidence) {
-  return new Map(querySet.queries.map((query, index) => [
-    query.id,
-    sensorEvidence.outcomes[index],
-  ]));
-}
-
-function statusesForSurface(surface, outcomes, anchor, { proposed }) {
-  const statuses = [
-    exactQueryStatus(
-      outcomes.get(surface.production.query_id),
-      surface.production.symbol,
-      surface.production.path,
-    ),
-    exactResolutionStatus(
-      outcomes.get(surface.production.impact_id),
-      surface.production.symbol,
-      surface.production.path,
-    ),
-  ];
-  if (proposed) {
-    statuses.push(callerLinkStatus(
-      outcomes.get(surface.production.link_query_id),
-      surface.production,
-      anchor,
-    ));
-  }
-  for (const test of surface.tests) {
-    const target = test.symbol ?? test.path;
-    statuses.push(exactQueryStatus(outcomes.get(test.query_id), target, test.path));
-    if (test.impact_id !== null) {
-      statuses.push(exactResolutionStatus(outcomes.get(test.impact_id), target, test.path));
-    }
-  }
-  return statuses;
-}
-
-function deriveSurfaceMode(planInput, candidateSpec, outcomes) {
-  const current = [];
-  const proposed = [];
-  for (const candidate of candidateSpec.todos) {
-    const anchor = planInput.todos.find(({ id }) => id === candidate.todo_id).anchor;
-    current.push(...statusesForSurface(candidate.current, outcomes, anchor, { proposed: false }));
-    proposed.push(...statusesForSurface(candidate.proposed, outcomes, anchor, { proposed: true }));
-  }
-  if (current.every((status) => status === 'ready')
-    && proposed.every((status) => status === 'absent')) {
-    return { mode: 'current', unknowns: [] };
-  }
-  if (current.every((status) => status === 'ready')
-    && proposed.every((status) => status === 'ready')) {
-    return { mode: 'proposed', unknowns: [] };
-  }
-  return {
-    mode: 'current',
-    unknowns: [
-      `surface_resolution_unknown:current=${current.join(',')}:proposed=${proposed.join(',')}`,
-    ],
-  };
-}
-
-function surfaceResources(surface) {
-  return uniqueResources([
-    { kind: 'symbol', target: surface.production.symbol },
-    { kind: 'path', target: surface.production.path },
-    ...surface.tests.flatMap((test) => [
-      ...(test.symbol === null ? [] : [{ kind: 'symbol', target: test.symbol }]),
-      { kind: 'path', target: test.path },
-    ]),
-  ]);
-}
-
-function surfaceEvidenceRefs(surface) {
-  return unique([
-    surface.production.query_id,
-    surface.production.impact_id,
-    surface.production.link_query_id,
-    ...surface.tests.flatMap((test) => [test.query_id, test.impact_id].filter(Boolean)),
-  ]).sort();
-}
-
-function manualByTodo(manualEvidence) {
-  return new Map(manualEvidence.evidence.map((entry) => [entry.todo_id, entry]));
-}
-
-function manualRecordId(todoId) {
-  return `manual-${todoId}`;
-}
-
-function conflictId(kind, index) {
-  return `${kind}-${String(index + 1).padStart(3, '0')}`;
-}
-
-function compileConflicts(todoDrafts, graphUnknowns) {
-  const conflicts = [];
-  let writeIndex = 0;
-  let stateIndex = 0;
-  let effectIndex = 0;
-  for (let leftIndex = 0; leftIndex < todoDrafts.length; leftIndex += 1) {
-    for (let rightIndex = leftIndex + 1; rightIndex < todoDrafts.length; rightIndex += 1) {
-      const left = todoDrafts[leftIndex];
-      const right = todoDrafts[rightIndex];
-      const rightOwns = new Set(right.owns.map(resourceKey));
-      for (const resource of left.owns.filter((entry) => rightOwns.has(resourceKey(entry)))) {
-        conflicts.push({
-          id: conflictId('write-overlap', writeIndex++),
-          kind: 'write_boundary',
-          todo_ids: [left.id, right.id],
-          resource,
-          evidence_refs: unique([...left.graphRefs, ...right.graphRefs]).sort(),
-        });
-      }
-
-      const stateTargets = unique([
-        ...left.manual.state_reads,
-        ...left.manual.state_writes,
-      ].filter((target) => (
-        right.manual.state_reads.includes(target) || right.manual.state_writes.includes(target)
-      ) && (
-        left.manual.state_writes.includes(target) || right.manual.state_writes.includes(target)
-      ))).sort();
-      for (const target of stateTargets) {
-        conflicts.push({
-          id: conflictId('state-overlap', stateIndex++),
-          kind: 'state',
-          todo_ids: [left.id, right.id],
-          resource: { kind: 'state', target },
-          evidence_refs: [manualRecordId(left.id), manualRecordId(right.id)],
-        });
-      }
-
-      for (const target of left.manual.effects
-        .filter((entry) => right.manual.effects.includes(entry)).sort()) {
-        conflicts.push({
-          id: conflictId('effect-overlap', effectIndex++),
-          kind: 'effect',
-          todo_ids: [left.id, right.id],
-          resource: { kind: 'effect', target },
-          evidence_refs: [manualRecordId(left.id), manualRecordId(right.id)],
-        });
-      }
-    }
-  }
-
-  const allUnknowns = unique([
-    ...graphUnknowns,
-    ...todoDrafts.flatMap(({ unknowns }) => unknowns),
-  ]);
-  if (allUnknowns.length > 0 && todoDrafts.length >= 2) {
-    const resource = { kind: 'dynamic', target: 'unresolved-boundary' };
-    for (const draft of todoDrafts) draft.dynamicWrites.push(resource);
-    conflicts.push({
-      id: 'dynamic-unknown-001',
-      kind: 'dynamic_unknown',
-      todo_ids: [todoDrafts[0].id, todoDrafts[1].id],
-      resource,
-      evidence_refs: unique([
-        ...todoDrafts.flatMap(({ graphRefs }) => graphRefs),
-        ...todoDrafts.map(({ id }) => manualRecordId(id)),
-      ]).sort(),
-    });
-  }
-  return { conflicts, allUnknowns };
-}
-
-function graphRecords(querySet, sensorEvidence) {
-  return querySet.queries.map((query, index) => ({
-    id: query.id,
-    operation: query.operation,
-    status: sensorEvidence.outcomes[index].outcome,
-    result_digest: digestArtifact(portableSensorOutcome(sensorEvidence.outcomes[index])),
-  }));
-}
-
-function compileManifest({
-  planInput,
-  candidateSpec,
-  manualEvidence,
-  querySet,
-  sensorEvidence,
-  codeSnapshotDigest,
-  surfaceMode,
-  graphUnknowns,
-  sensorVersion,
-}) {
-  const manuals = manualByTodo(manualEvidence);
-  const candidates = new Map(candidateSpec.todos.map((todo) => [todo.todo_id, todo]));
-  const stableTests = candidateSpec.stable_surfaces
-    .filter((surface) => surface.kind === 'path'
-      && (surface.active_when === 'always' || surfaceMode === 'proposed'))
-    .map(({ path: testPath }) => testPath);
-  const drafts = planInput.todos.map((todo) => {
-    const active = candidates.get(todo.id)[surfaceMode];
-    const manual = manuals.get(todo.id);
-    return {
-      id: todo.id,
-      owns: surfaceResources(active),
-      graphRefs: surfaceEvidenceRefs(active),
-      manual,
-      dynamicWrites: [],
-      unknowns: manual.unknowns.map((unknown) => `manual_unknown:${todo.id}:${unknown}`),
-      tests: unique([...active.tests.map(({ path: testPath }) => testPath), ...stableTests]).sort(),
-    };
-  });
-  const { conflicts, allUnknowns } = compileConflicts(drafts, graphUnknowns);
-  const todos = drafts.map((draft) => ({
-    id: draft.id,
-    owns: draft.owns,
-    reads: draft.manual.state_reads.map((target) => ({ kind: 'state', target })),
-    writes: uniqueResources([
-      ...draft.owns,
-      ...draft.manual.state_writes.map((target) => ({ kind: 'state', target })),
-      ...draft.manual.effects.map((target) => ({ kind: 'effect', target })),
-      ...draft.dynamicWrites,
-    ]),
-    hard_needs: [],
-    conflict_ids: conflicts.filter(({ todo_ids: todoIds }) => todoIds.includes(draft.id))
-      .map(({ id }) => id),
-    unknowns: unique([...graphUnknowns, ...draft.unknowns]),
-    tests: draft.tests,
-    evidence_refs: unique([...draft.graphRefs, manualRecordId(draft.id)]).sort(),
-  }));
-  const manifest = {
-    schema: 'lattice.boundary_manifest.v1',
-    plan_input_digest: digestArtifact(planInput),
-    source: {
-      code_snapshot_digest: codeSnapshotDigest,
-      query_set_digest: digestArtifact(querySet),
-      manual_evidence_digest: digestArtifact(manualEvidence),
-      sensor_version: sensorVersion,
-    },
-    graph_evidence: graphRecords(querySet, sensorEvidence),
-    manual_evidence: planInput.todos.map((todo) => ({
-      id: manualRecordId(todo.id),
-      todo_id: todo.id,
-      result_digest: digestArtifact(manuals.get(todo.id)),
-    })),
-    todos,
-    conflicts,
-    unknowns: allUnknowns,
-  };
-  if (!validateBoundaryManifest(manifest)) fail('生成manifestがpublic contractを満たさない');
-  return manifest;
-}
-
-function compileVerdict(manifest, candidateSpec, surfaceMode) {
-  const hasUnknown = manifest.unknowns.length > 0;
-  const hasManualConflict = manifest.conflicts.some(({ kind }) => kind === 'state' || kind === 'effect');
-  const hasWriteConflict = manifest.conflicts.some(({ kind }) => kind === 'write_boundary');
-  let verdict;
-  let reasons;
-  let seamCandidate = null;
-  if (hasUnknown) {
-    verdict = 'unknown_requires_evidence';
-    reasons = ['graphまたはmanual unknownが残るためindependenceを確定できない'];
-  } else if (hasManualConflict) {
-    verdict = 'intentional_serial';
-    reasons = ['shared manual state/effect conflictはcode seamでは切断できない'];
-  } else if (hasWriteConflict && surfaceMode === 'current') {
-    verdict = 'seam_candidate';
-    reasons = ['current production/test write overlapはcandidate specのproposed surfaceへ切断可能'];
-    seamCandidate = {
-      id: candidateSpec.candidate_id,
-      proposed_owns: candidateSpec.todos.map((todo) => ({
-        todo_id: todo.todo_id,
-        resources: surfaceResources(todo.proposed),
-      })),
-      preconditions: [
-        'all proposed production and test surfaces resolve exactly',
-        'transform-external black-box oracle passes before and after',
-      ],
-    };
-  } else if (hasWriteConflict) {
-    verdict = 'intentional_serial';
-    reasons = ['proposed surfaceにもwrite overlapが残るため追加seamまたはjoinが必要'];
-  } else {
-    verdict = 'parallel_ready';
-    reasons = ['same compilerが全production/test write resourceの非重複を導出した'];
-  }
-  const artifact = {
-    schema: 'lattice.boundary_verdict.v1',
-    boundary_manifest_digest: digestArtifact(manifest),
-    verdicts: [{
-      id: 'channel-label-verdict-v4',
-      todo_ids: manifest.todos.map(({ id }) => id),
-      verdict,
-      conflict_ids: manifest.conflicts.map(({ id }) => id),
-      seam_candidate: seamCandidate,
-      reasons,
-      unknowns: manifest.unknowns,
-    }],
-  };
-  if (!validateBoundaryVerdict(artifact)) fail('生成verdictがpublic contractを満たさない');
-  return artifact;
-}
-
-function compilePlan(planInput, manifest, planVersion) {
-  const edgeKinds = new Map([
-    ['write_boundary', 'write_conflict'],
-    ['state', 'state_conflict'],
-    ['effect', 'effect_conflict'],
-    ['semantic', 'semantic_conflict'],
-    ['dynamic_unknown', 'dynamic_unknown'],
-  ]);
-  const edges = manifest.conflicts.map((conflict) => ({
-    id: conflict.id,
-    from: conflict.todo_ids[0],
-    to: conflict.todo_ids[1],
-    kind: edgeKinds.get(conflict.kind),
-    evidence_refs: conflict.evidence_refs,
-  }));
-  const waves = edges.length === 0
-    ? [{ index: 0, todo_ids: planInput.todos.map(({ id }) => id) }]
-    : planInput.todos.map((todo, index) => ({ index, todo_ids: [todo.id] }));
-  const graph = {
-    schema: 'lattice.plan_graph.v1',
-    plan_version: planVersion,
-    source_manifest_digest: digestArtifact(manifest),
-    capacity: { writers: planInput.capacity.writers },
-    nodes: planInput.todos.map((todo) => ({
-      id: todo.id,
-      outcome: todo.outcome,
-      owned_boundaries: manifest.todos.find(({ id }) => id === todo.id).owns,
-    })),
-    edges,
-    joins: [],
-    waves,
-    minimum_feasible_waves: waves.length,
-  };
-  if (!validatePlanGraph(graph)) fail('生成plan graphがpublic contractを満たさない');
-  return graph;
-}
-
-/**
- * 同じcandidate specと規則から任意code snapshotのRC1 boundaryをcompileする。
- * @param {object} options
- * @returns {object}
- */
-export function compileBoundaryCondition(options = {}) {
-  if (isPlainObject(options) && Object.hasOwn(options, 'condition')) {
-    fail('condition selector is forbidden');
-  }
-  if (!exactRecord(options, OPTION_KEYS)) fail('compiler optionsがexact shapeでない');
-  const {
-    planInput,
-    candidateSpec,
-    manualEvidence,
-    querySet,
-    sensorEvidence,
-    codeSnapshotDigest,
-    planVersion,
-  } = options;
-  for (const value of [planInput, candidateSpec, manualEvidence, querySet, sensorEvidence]) {
-    canonicalizeArtifact(value);
-  }
-  if (!validatePlanInput(planInput)
-    || planInput.todos.length !== 2
-    || planInput.capacity.writers !== 2) {
-    fail('RC1 plan inputがpublic contractまたは固定topologyを満たさない');
-  }
-  if (!SHA256.test(codeSnapshotDigest) || !identifier(planVersion)) {
-    fail('snapshot digestまたはplan versionが不正');
-  }
-  assertManualEvidence(planInput, manualEvidence);
-  assertCandidateSpec(planInput, candidateSpec);
-  assertQuerySet(querySet, candidateSpec);
-  assertLatticeSensorEvidence(querySet, sensorEvidence);
-  const outcomes = outcomeMap(querySet, sensorEvidence);
-  const statusQuery = querySet.queries.find(({ operation }) => operation === 'status');
-  const status = outcomes.get(statusQuery.id);
-  if (status.outcome !== 'ready' || !nonEmptyText(status.data?.version)) {
-    fail(`LatticeSensor statusがreadyでない: ${status.outcome}`);
-  }
-  const selection = deriveSurfaceMode(planInput, candidateSpec, outcomes);
-  const boundaryManifest = compileManifest({
-    planInput,
-    candidateSpec,
-    manualEvidence,
-    querySet,
-    sensorEvidence,
-    codeSnapshotDigest,
-    surfaceMode: selection.mode,
-    graphUnknowns: selection.unknowns,
-    sensorVersion: status.data.version,
-  });
-  const boundaryVerdict = compileVerdict(boundaryManifest, candidateSpec, selection.mode);
-  const planGraph = compilePlan(planInput, boundaryManifest, planVersion);
-  return {
-    compiler: { ...RC1_BOUNDARY_COMPILER_CONTRACT },
-    candidate_spec_digest: digestArtifact(candidateSpec),
-    surface_mode: selection.mode,
-    boundary_manifest: boundaryManifest,
-    boundary_manifest_digest: digestArtifact(boundaryManifest),
-    boundary_verdict: boundaryVerdict,
-    boundary_verdict_digest: digestArtifact(boundaryVerdict),
-    plan_graph: planGraph,
-    plan_graph_digest: digestArtifact(planGraph),
-  };
-}
+import {
+  canonicalizeArtifact,
+  digestArtifact,
+  validateBoundaryManifest,
+  validateBoundaryVerdict,
+  validatePlanGraph,
+  validatePlanInput,
+} from './artifact-contracts.mjs';
+import { portableSensorOutcome } from './sensor-adapter.mjs';
+
+const SHA256 = /^[0-9a-f]{64}$/;
+const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
+const OPERATIONS = new Set(['status', 'query', 'callers', 'callees', 'impact', 'affected']);
+const OPTION_KEYS = [
+  'candidateSpec',
+  'codeSnapshotDigest',
+  'sensorEvidence',
+  'manualEvidence',
+  'planInput',
+  'planVersion',
+  'querySet',
+];
+
+export const RC1_BOUNDARY_COMPILER_CONTRACT = Object.freeze({
+  export_name: 'compileBoundaryCondition',
+  condition_selector: 'forbidden',
+  surface_resolution: 'exact_graph_name_or_qualified_name_at_expected_path',
+  conflict_rule: 'pairwise_write_resource_intersection',
+});
+
+function fail(reason) {
+  throw new TypeError(`RC1 v4 boundary compiler契約違反: ${reason}`);
+}
+
+function isPlainObject(value) {
+  return value !== null
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+function exactRecord(value, keys) {
+  if (!isPlainObject(value)) 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 nonEmptyText(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 4_096;
+}
+
+function identifier(value) {
+  return typeof value === 'string' && IDENTIFIER.test(value);
+}
+
+function repoPath(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value.length <= 1_024
+    && !value.includes('\0')
+    && !value.startsWith('/')
+    && !value.split('/').includes('..');
+}
+
+function unique(values) {
+  return [...new Set(values)];
+}
+
+function resourceKey(value) {
+  return `${value.kind}\0${value.target}`;
+}
+
+function uniqueResources(values) {
+  return [...new Map(values.map((value) => [resourceKey(value), value])).values()]
+    .sort((left, right) => resourceKey(left).localeCompare(resourceKey(right)));
+}
+
+function assertManualEvidence(planInput, manualEvidence) {
+  if (!exactRecord(manualEvidence, ['schema', 'evidence'])
+    || manualEvidence.schema !== 'lattice.manual_boundary_evidence.v1'
+    || !Array.isArray(manualEvidence.evidence)
+    || manualEvidence.evidence.length !== planInput.todos.length) {
+    fail('manual evidence rootがplan inputと一致しない');
+  }
+  const todoIds = planInput.todos.map(({ id }) => id);
+  if (new Set(manualEvidence.evidence.map(({ todo_id: todoId }) => todoId)).size !== todoIds.length) {
+    fail('manual evidence todo IDが一意でない');
+  }
+  for (const entry of manualEvidence.evidence) {
+    if (!exactRecord(entry, ['todo_id', 'state_reads', 'state_writes', 'effects', 'unknowns'])
+      || !todoIds.includes(entry.todo_id)
+      || ![entry.state_reads, entry.state_writes, entry.effects, entry.unknowns]
+        .every((values) => Array.isArray(values)
+          && values.every(nonEmptyText)
+          && new Set(values).size === values.length)) {
+      fail('manual evidence recordが不正');
+    }
+  }
+}
+
+function assertTestSurface(value, { proposed }) {
+  if (!exactRecord(value, [
+    'symbol',
+    'path',
+    'query_id',
+    'impact_id',
+    'assertion_id',
+    'provenance',
+  ])
+    || (proposed ? !nonEmptyText(value.symbol) : value.symbol !== null)
+    || !repoPath(value.path)
+    || !identifier(value.query_id)
+    || (proposed ? !identifier(value.impact_id) : value.impact_id !== null)
+    || !identifier(value.assertion_id)
+    || !exactRecord(value.provenance, ['kind', 'ref'])
+    || value.provenance.kind !== 'todo_outcome'
+    || !nonEmptyText(value.provenance.ref)) {
+    fail(`${proposed ? 'proposed' : 'current'} test surfaceが不正`);
+  }
+}
+
+function assertProductionSurface(value) {
+  if (!exactRecord(value, ['symbol', 'path', 'query_id', 'impact_id', 'link_query_id'])
+    || !nonEmptyText(value.symbol)
+    || !repoPath(value.path)
+    || !identifier(value.query_id)
+    || !identifier(value.impact_id)
+    || !identifier(value.link_query_id)) {
+    fail('production surfaceが不正');
+  }
+}
+
+function assertCandidateSpec(planInput, candidateSpec) {
+  if (!exactRecord(candidateSpec, [
+    'schema',
+    'candidate_id',
+    'plan_input_ref',
+    'query_set_ref',
+    'behavior_oracle_ref',
+    'compiler_contract',
+    'stable_surfaces',
+    'todos',
+  ])
+    || candidateSpec.schema !== 'lattice.rc1.boundary_candidate_spec.v2'
+    || !identifier(candidateSpec.candidate_id)
+    || !repoPath(candidateSpec.plan_input_ref)
+    || !repoPath(candidateSpec.query_set_ref)
+    || !repoPath(candidateSpec.behavior_oracle_ref)
+    || !exactRecord(candidateSpec.compiler_contract, [
+      'condition_selector',
+      'surface_resolution',
+      'proposed_activation',
+      'unresolved_policy',
+      'conflict_rule',
+    ])
+    || candidateSpec.compiler_contract.condition_selector !== 'forbidden'
+    || candidateSpec.compiler_contract.surface_resolution
+      !== 'exact_graph_name_or_qualified_name_at_expected_path'
+    || candidateSpec.compiler_contract.proposed_activation
+      !== 'all_proposed_production_and_test_surfaces_exact'
+    || candidateSpec.compiler_contract.unresolved_policy !== 'typed_unknown'
+    || candidateSpec.compiler_contract.conflict_rule !== 'pairwise_write_resource_intersection'
+    || !Array.isArray(candidateSpec.stable_surfaces)
+    || candidateSpec.stable_surfaces.length === 0
+    || !Array.isArray(candidateSpec.todos)
+    || candidateSpec.todos.length !== planInput.todos.length) {
+    fail('candidate spec rootが不正');
+  }
+
+  for (const surface of candidateSpec.stable_surfaces) {
+    if (!exactRecord(surface, ['kind', 'target', 'path', 'role', 'active_when'])
+      || !new Set(['symbol', 'path']).has(surface.kind)
+      || !nonEmptyText(surface.target)
+      || !repoPath(surface.path)
+      || !identifier(surface.role)
+      || !new Set(['always', 'proposed']).has(surface.active_when)) {
+      fail('stable surfaceが不正');
+    }
+  }
+
+  const planTodos = new Map(planInput.todos.map((todo) => [todo.id, todo]));
+  for (const todo of candidateSpec.todos) {
+    if (!exactRecord(todo, ['todo_id', 'outcome', 'current', 'proposed'])
+      || !planTodos.has(todo.todo_id)
+      || todo.outcome !== planTodos.get(todo.todo_id).outcome) {
+      fail('candidate TODOがplan inputと一致しない');
+    }
+    for (const [mode, proposed] of [['current', false], ['proposed', true]]) {
+      const value = todo[mode];
+      if (!exactRecord(value, ['production', 'tests'])
+        || !Array.isArray(value.tests)
+        || value.tests.length === 0) {
+        fail(`${mode} surface setが不正`);
+      }
+      assertProductionSurface(value.production);
+      for (const test of value.tests) assertTestSurface(test, { proposed });
+    }
+  }
+  if (new Set(candidateSpec.todos.map(({ todo_id: todoId }) => todoId)).size
+    !== planInput.todos.length) {
+    fail('candidate TODO IDが一意でない');
+  }
+}
+
+function assertQuerySet(querySet, candidateSpec) {
+  if (!exactRecord(querySet, ['schema', 'queries'])
+    || querySet.schema !== 'lattice.sensor_query_set.v2'
+    || !Array.isArray(querySet.queries)
+    || querySet.queries.length === 0
+    || querySet.queries.length > 256) {
+    fail('query set rootが不正');
+  }
+  const ids = new Set();
+  for (const query of querySet.queries) {
+    if (!isPlainObject(query) || !identifier(query.id) || ids.has(query.id)
+      || !OPERATIONS.has(query.operation)) {
+      fail('query set recordが不正');
+    }
+    ids.add(query.id);
+    if (query.operation === 'status') {
+      if (!exactRecord(query, ['id', 'operation'])) fail('status query shapeが不正');
+    } else if (query.operation === 'affected') {
+      if (!exactRecord(query, ['id', 'operation', 'targets'])
+        || !Array.isArray(query.targets)
+        || query.targets.length === 0
+        || !query.targets.every(repoPath)
+        || new Set(query.targets).size !== query.targets.length) {
+        fail('affected query shapeが不正');
+      }
+    } else if (!exactRecord(query, ['id', 'operation', 'target'])
+      || !nonEmptyText(query.target)) {
+      fail('graph query shapeが不正');
+    }
+  }
+  if (querySet.queries.filter(({ operation }) => operation === 'status').length !== 1
+    || querySet.queries.filter(({ operation }) => operation === 'affected').length !== 1) {
+    fail('query setにstatusとaffectedがexactly one必要');
+  }
+
+  const referenced = candidateSpec.todos.flatMap((todo) => [todo.current, todo.proposed]
+    .flatMap((surface) => [
+      surface.production.query_id,
+      surface.production.impact_id,
+      surface.production.link_query_id,
+      ...surface.tests.flatMap((entry) => [entry.query_id, entry.impact_id].filter(Boolean)),
+    ]));
+  if (referenced.some((id) => !ids.has(id))) {
+    fail('candidate specがquery set外のIDを参照する');
+  }
+}
+
+function assertLatticeSensorEvidence(querySet, sensorEvidence) {
+  if (!isPlainObject(sensorEvidence)
+    || !Array.isArray(sensorEvidence.outcomes)
+    || sensorEvidence.outcomes.length !== querySet.queries.length) {
+    fail('LatticeSensor evidence rootがquery setと一致しない');
+  }
+  for (let index = 0; index < querySet.queries.length; index += 1) {
+    const query = querySet.queries[index];
+    const outcome = sensorEvidence.outcomes[index];
+    if (!isPlainObject(outcome)
+      || outcome.id !== query.id
+      || outcome.operation !== query.operation
+      || !nonEmptyText(outcome.outcome)) {
+      fail(`LatticeSensor evidence ${query.id}がID／operation／順序と一致しない`);
+    }
+    if (query.operation !== 'status' && query.operation !== 'affected'
+      && outcome.target !== query.target) {
+      fail(`LatticeSensor evidence ${query.id}のtargetがquery setと一致しない`);
+    }
+    if (query.operation === 'affected'
+      && (!Array.isArray(outcome.targets)
+        || outcome.targets.length !== query.targets.length
+        || outcome.targets.some((entry, targetIndex) => (
+          !isPlainObject(entry) || entry.target !== query.targets[targetIndex]
+        )))) {
+      fail(`LatticeSensor evidence ${query.id}のaffected targetがquery setと一致しない`);
+    }
+  }
+}
+
+function exactNodeAt(records, target, expectedPath) {
+  if (!Array.isArray(records)) return false;
+  const exact = records.filter((entry) => isPlainObject(entry?.node)
+    && (entry.node.name === target || entry.node.qualifiedName === target)
+    && entry.node.filePath === expectedPath);
+  return exact.length === 1;
+}
+
+function exactQueryStatus(outcome, target, expectedPath) {
+  if (outcome?.outcome === 'symbol_absent') return 'absent';
+  if (outcome?.outcome !== 'ready') return 'unknown';
+  return exactNodeAt(outcome.data, target, expectedPath) ? 'ready' : 'unknown';
+}
+
+function exactResolutionStatus(outcome, target, expectedPath) {
+  if (outcome?.outcome === 'symbol_absent') return 'absent';
+  if (outcome?.outcome !== 'ready') return 'unknown';
+  return exactNodeAt(outcome.resolution, target, expectedPath) ? 'ready' : 'unknown';
+}
+
+function callerLinkStatus(outcome, production, anchor) {
+  const resolution = exactResolutionStatus(outcome, production.symbol, production.path);
+  if (resolution !== 'ready') return resolution;
+  const callers = outcome.data?.callers;
+  if (!Array.isArray(callers)) return 'unknown';
+  return callers.some((entry) => entry?.name === anchor.symbol && entry?.filePath === anchor.path)
+    ? 'ready'
+    : 'unknown';
+}
+
+function outcomeMap(querySet, sensorEvidence) {
+  return new Map(querySet.queries.map((query, index) => [
+    query.id,
+    sensorEvidence.outcomes[index],
+  ]));
+}
+
+function statusesForSurface(surface, outcomes, anchor, { proposed }) {
+  const statuses = [
+    exactQueryStatus(
+      outcomes.get(surface.production.query_id),
+      surface.production.symbol,
+      surface.production.path,
+    ),
+    exactResolutionStatus(
+      outcomes.get(surface.production.impact_id),
+      surface.production.symbol,
+      surface.production.path,
+    ),
+  ];
+  if (proposed) {
+    statuses.push(callerLinkStatus(
+      outcomes.get(surface.production.link_query_id),
+      surface.production,
+      anchor,
+    ));
+  }
+  for (const test of surface.tests) {
+    const target = test.symbol ?? test.path;
+    statuses.push(exactQueryStatus(outcomes.get(test.query_id), target, test.path));
+    if (test.impact_id !== null) {
+      statuses.push(exactResolutionStatus(outcomes.get(test.impact_id), target, test.path));
+    }
+  }
+  return statuses;
+}
+
+function deriveSurfaceMode(planInput, candidateSpec, outcomes) {
+  const current = [];
+  const proposed = [];
+  for (const candidate of candidateSpec.todos) {
+    const anchor = planInput.todos.find(({ id }) => id === candidate.todo_id).anchor;
+    current.push(...statusesForSurface(candidate.current, outcomes, anchor, { proposed: false }));
+    proposed.push(...statusesForSurface(candidate.proposed, outcomes, anchor, { proposed: true }));
+  }
+  if (current.every((status) => status === 'ready')
+    && proposed.every((status) => status === 'absent')) {
+    return { mode: 'current', unknowns: [] };
+  }
+  if (current.every((status) => status === 'ready')
+    && proposed.every((status) => status === 'ready')) {
+    return { mode: 'proposed', unknowns: [] };
+  }
+  return {
+    mode: 'current',
+    unknowns: [
+      `surface_resolution_unknown:current=${current.join(',')}:proposed=${proposed.join(',')}`,
+    ],
+  };
+}
+
+function surfaceResources(surface) {
+  return uniqueResources([
+    { kind: 'symbol', target: surface.production.symbol },
+    { kind: 'path', target: surface.production.path },
+    ...surface.tests.flatMap((test) => [
+      ...(test.symbol === null ? [] : [{ kind: 'symbol', target: test.symbol }]),
+      { kind: 'path', target: test.path },
+    ]),
+  ]);
+}
+
+function surfaceEvidenceRefs(surface) {
+  return unique([
+    surface.production.query_id,
+    surface.production.impact_id,
+    surface.production.link_query_id,
+    ...surface.tests.flatMap((test) => [test.query_id, test.impact_id].filter(Boolean)),
+  ]).sort();
+}
+
+function manualByTodo(manualEvidence) {
+  return new Map(manualEvidence.evidence.map((entry) => [entry.todo_id, entry]));
+}
+
+function manualRecordId(todoId) {
+  return `manual-${todoId}`;
+}
+
+function conflictId(kind, index) {
+  return `${kind}-${String(index + 1).padStart(3, '0')}`;
+}
+
+function compileConflicts(todoDrafts, graphUnknowns) {
+  const conflicts = [];
+  let writeIndex = 0;
+  let stateIndex = 0;
+  let effectIndex = 0;
+  for (let leftIndex = 0; leftIndex < todoDrafts.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < todoDrafts.length; rightIndex += 1) {
+      const left = todoDrafts[leftIndex];
+      const right = todoDrafts[rightIndex];
+      const rightOwns = new Set(right.owns.map(resourceKey));
+      for (const resource of left.owns.filter((entry) => rightOwns.has(resourceKey(entry)))) {
+        conflicts.push({
+          id: conflictId('write-overlap', writeIndex++),
+          kind: 'write_boundary',
+          todo_ids: [left.id, right.id],
+          resource,
+          evidence_refs: unique([...left.graphRefs, ...right.graphRefs]).sort(),
+        });
+      }
+
+      const stateTargets = unique([
+        ...left.manual.state_reads,
+        ...left.manual.state_writes,
+      ].filter((target) => (
+        right.manual.state_reads.includes(target) || right.manual.state_writes.includes(target)
+      ) && (
+        left.manual.state_writes.includes(target) || right.manual.state_writes.includes(target)
+      ))).sort();
+      for (const target of stateTargets) {
+        conflicts.push({
+          id: conflictId('state-overlap', stateIndex++),
+          kind: 'state',
+          todo_ids: [left.id, right.id],
+          resource: { kind: 'state', target },
+          evidence_refs: [manualRecordId(left.id), manualRecordId(right.id)],
+        });
+      }
+
+      for (const target of left.manual.effects
+        .filter((entry) => right.manual.effects.includes(entry)).sort()) {
+        conflicts.push({
+          id: conflictId('effect-overlap', effectIndex++),
+          kind: 'effect',
+          todo_ids: [left.id, right.id],
+          resource: { kind: 'effect', target },
+          evidence_refs: [manualRecordId(left.id), manualRecordId(right.id)],
+        });
+      }
+    }
+  }
+
+  const allUnknowns = unique([
+    ...graphUnknowns,
+    ...todoDrafts.flatMap(({ unknowns }) => unknowns),
+  ]);
+  if (allUnknowns.length > 0 && todoDrafts.length >= 2) {
+    const resource = { kind: 'dynamic', target: 'unresolved-boundary' };
+    for (const draft of todoDrafts) draft.dynamicWrites.push(resource);
+    conflicts.push({
+      id: 'dynamic-unknown-001',
+      kind: 'dynamic_unknown',
+      todo_ids: [todoDrafts[0].id, todoDrafts[1].id],
+      resource,
+      evidence_refs: unique([
+        ...todoDrafts.flatMap(({ graphRefs }) => graphRefs),
+        ...todoDrafts.map(({ id }) => manualRecordId(id)),
+      ]).sort(),
+    });
+  }
+  return { conflicts, allUnknowns };
+}
+
+function graphRecords(querySet, sensorEvidence) {
+  return querySet.queries.map((query, index) => ({
+    id: query.id,
+    operation: query.operation,
+    status: sensorEvidence.outcomes[index].outcome,
+    result_digest: digestArtifact(portableSensorOutcome(sensorEvidence.outcomes[index])),
+  }));
+}
+
+function compileManifest({
+  planInput,
+  candidateSpec,
+  manualEvidence,
+  querySet,
+  sensorEvidence,
+  codeSnapshotDigest,
+  surfaceMode,
+  graphUnknowns,
+  sensorVersion,
+}) {
+  const manuals = manualByTodo(manualEvidence);
+  const candidates = new Map(candidateSpec.todos.map((todo) => [todo.todo_id, todo]));
+  const stableTests = candidateSpec.stable_surfaces
+    .filter((surface) => surface.kind === 'path'
+      && (surface.active_when === 'always' || surfaceMode === 'proposed'))
+    .map(({ path: testPath }) => testPath);
+  const drafts = planInput.todos.map((todo) => {
+    const active = candidates.get(todo.id)[surfaceMode];
+    const manual = manuals.get(todo.id);
+    return {
+      id: todo.id,
+      owns: surfaceResources(active),
+      graphRefs: surfaceEvidenceRefs(active),
+      manual,
+      dynamicWrites: [],
+      unknowns: manual.unknowns.map((unknown) => `manual_unknown:${todo.id}:${unknown}`),
+      tests: unique([...active.tests.map(({ path: testPath }) => testPath), ...stableTests]).sort(),
+    };
+  });
+  const { conflicts, allUnknowns } = compileConflicts(drafts, graphUnknowns);
+  const todos = drafts.map((draft) => ({
+    id: draft.id,
+    owns: draft.owns,
+    reads: draft.manual.state_reads.map((target) => ({ kind: 'state', target })),
+    writes: uniqueResources([
+      ...draft.owns,
+      ...draft.manual.state_writes.map((target) => ({ kind: 'state', target })),
+      ...draft.manual.effects.map((target) => ({ kind: 'effect', target })),
+      ...draft.dynamicWrites,
+    ]),
+    hard_needs: [],
+    conflict_ids: conflicts.filter(({ todo_ids: todoIds }) => todoIds.includes(draft.id))
+      .map(({ id }) => id),
+    unknowns: unique([...graphUnknowns, ...draft.unknowns]),
+    tests: draft.tests,
+    evidence_refs: unique([...draft.graphRefs, manualRecordId(draft.id)]).sort(),
+  }));
+  const manifest = {
+    schema: 'lattice.boundary_manifest.v1',
+    plan_input_digest: digestArtifact(planInput),
+    source: {
+      code_snapshot_digest: codeSnapshotDigest,
+      query_set_digest: digestArtifact(querySet),
+      manual_evidence_digest: digestArtifact(manualEvidence),
+      sensor_version: sensorVersion,
+    },
+    graph_evidence: graphRecords(querySet, sensorEvidence),
+    manual_evidence: planInput.todos.map((todo) => ({
+      id: manualRecordId(todo.id),
+      todo_id: todo.id,
+      result_digest: digestArtifact(manuals.get(todo.id)),
+    })),
+    todos,
+    conflicts,
+    unknowns: allUnknowns,
+  };
+  if (!validateBoundaryManifest(manifest)) fail('生成manifestがpublic contractを満たさない');
+  return manifest;
+}
+
+function compileVerdict(manifest, candidateSpec, surfaceMode) {
+  const hasUnknown = manifest.unknowns.length > 0;
+  const hasManualConflict = manifest.conflicts.some(({ kind }) => kind === 'state' || kind === 'effect');
+  const hasWriteConflict = manifest.conflicts.some(({ kind }) => kind === 'write_boundary');
+  let verdict;
+  let reasons;
+  let seamCandidate = null;
+  if (hasUnknown) {
+    verdict = 'unknown_requires_evidence';
+    reasons = ['graphまたはmanual unknownが残るためindependenceを確定できない'];
+  } else if (hasManualConflict) {
+    verdict = 'intentional_serial';
+    reasons = ['shared manual state/effect conflictはcode seamでは切断できない'];
+  } else if (hasWriteConflict && surfaceMode === 'current') {
+    verdict = 'seam_candidate';
+    reasons = ['current production/test write overlapはcandidate specのproposed surfaceへ切断可能'];
+    seamCandidate = {
+      id: candidateSpec.candidate_id,
+      proposed_owns: candidateSpec.todos.map((todo) => ({
+        todo_id: todo.todo_id,
+        resources: surfaceResources(todo.proposed),
+      })),
+      preconditions: [
+        'all proposed production and test surfaces resolve exactly',
+        'transform-external black-box oracle passes before and after',
+      ],
+    };
+  } else if (hasWriteConflict) {
+    verdict = 'intentional_serial';
+    reasons = ['proposed surfaceにもwrite overlapが残るため追加seamまたはjoinが必要'];
+  } else {
+    verdict = 'parallel_ready';
+    reasons = ['same compilerが全production/test write resourceの非重複を導出した'];
+  }
+  const artifact = {
+    schema: 'lattice.boundary_verdict.v1',
+    boundary_manifest_digest: digestArtifact(manifest),
+    verdicts: [{
+      id: 'channel-label-verdict-v4',
+      todo_ids: manifest.todos.map(({ id }) => id),
+      verdict,
+      conflict_ids: manifest.conflicts.map(({ id }) => id),
+      seam_candidate: seamCandidate,
+      reasons,
+      unknowns: manifest.unknowns,
+    }],
+  };
+  if (!validateBoundaryVerdict(artifact)) fail('生成verdictがpublic contractを満たさない');
+  return artifact;
+}
+
+function compilePlan(planInput, manifest, planVersion) {
+  const edgeKinds = new Map([
+    ['write_boundary', 'write_conflict'],
+    ['state', 'state_conflict'],
+    ['effect', 'effect_conflict'],
+    ['semantic', 'semantic_conflict'],
+    ['dynamic_unknown', 'dynamic_unknown'],
+  ]);
+  const edges = manifest.conflicts.map((conflict) => ({
+    id: conflict.id,
+    from: conflict.todo_ids[0],
+    to: conflict.todo_ids[1],
+    kind: edgeKinds.get(conflict.kind),
+    evidence_refs: conflict.evidence_refs,
+  }));
+  const waves = edges.length === 0
+    ? [{ index: 0, todo_ids: planInput.todos.map(({ id }) => id) }]
+    : planInput.todos.map((todo, index) => ({ index, todo_ids: [todo.id] }));
+  const graph = {
+    schema: 'lattice.plan_graph.v1',
+    plan_version: planVersion,
+    source_manifest_digest: digestArtifact(manifest),
+    capacity: { writers: planInput.capacity.writers },
+    nodes: planInput.todos.map((todo) => ({
+      id: todo.id,
+      outcome: todo.outcome,
+      owned_boundaries: manifest.todos.find(({ id }) => id === todo.id).owns,
+    })),
+    edges,
+    joins: [],
+    waves,
+    minimum_feasible_waves: waves.length,
+  };
+  if (!validatePlanGraph(graph)) fail('生成plan graphがpublic contractを満たさない');
+  return graph;
+}
+
+/**
+ * 同じcandidate specと規則から任意code snapshotのRC1 boundaryをcompileする。
+ * @param {object} options
+ * @returns {object}
+ */
+export function compileBoundaryCondition(options = {}) {
+  if (isPlainObject(options) && Object.hasOwn(options, 'condition')) {
+    fail('condition selector is forbidden');
+  }
+  if (!exactRecord(options, OPTION_KEYS)) fail('compiler optionsがexact shapeでない');
+  const {
+    planInput,
+    candidateSpec,
+    manualEvidence,
+    querySet,
+    sensorEvidence,
+    codeSnapshotDigest,
+    planVersion,
+  } = options;
+  for (const value of [planInput, candidateSpec, manualEvidence, querySet, sensorEvidence]) {
+    canonicalizeArtifact(value);
+  }
+  if (!validatePlanInput(planInput)
+    || planInput.todos.length !== 2
+    || planInput.capacity.writers !== 2) {
+    fail('RC1 plan inputがpublic contractまたは固定topologyを満たさない');
+  }
+  if (!SHA256.test(codeSnapshotDigest) || !identifier(planVersion)) {
+    fail('snapshot digestまたはplan versionが不正');
+  }
+  assertManualEvidence(planInput, manualEvidence);
+  assertCandidateSpec(planInput, candidateSpec);
+  assertQuerySet(querySet, candidateSpec);
+  assertLatticeSensorEvidence(querySet, sensorEvidence);
+  const outcomes = outcomeMap(querySet, sensorEvidence);
+  const statusQuery = querySet.queries.find(({ operation }) => operation === 'status');
+  const status = outcomes.get(statusQuery.id);
+  if (status.outcome !== 'ready' || !nonEmptyText(status.data?.version)) {
+    fail(`LatticeSensor statusがreadyでない: ${status.outcome}`);
+  }
+  const selection = deriveSurfaceMode(planInput, candidateSpec, outcomes);
+  const boundaryManifest = compileManifest({
+    planInput,
+    candidateSpec,
+    manualEvidence,
+    querySet,
+    sensorEvidence,
+    codeSnapshotDigest,
+    surfaceMode: selection.mode,
+    graphUnknowns: selection.unknowns,
+    sensorVersion: status.data.version,
+  });
+  const boundaryVerdict = compileVerdict(boundaryManifest, candidateSpec, selection.mode);
+  const planGraph = compilePlan(planInput, boundaryManifest, planVersion);
+  return {
+    compiler: { ...RC1_BOUNDARY_COMPILER_CONTRACT },
+    candidate_spec_digest: digestArtifact(candidateSpec),
+    surface_mode: selection.mode,
+    boundary_manifest: boundaryManifest,
+    boundary_manifest_digest: digestArtifact(boundaryManifest),
+    boundary_verdict: boundaryVerdict,
+    boundary_verdict_digest: digestArtifact(boundaryVerdict),
+    plan_graph: planGraph,
+    plan_graph_digest: digestArtifact(planGraph),
+  };
+}