@adrkit/evaluator 0.1.0

package/src/pass0.ts

@@ -0,0 +1,163 @@
+/**
+ * @adrkit/evaluator — Pass 0 orchestrator.
+ *
+ * Pure, total function of `input` (FR-006): same input ⇒ same typed input error or
+ * byte-identical report + patch. It performs NO clock/network/db/filesystem access,
+ * mutates nothing, imports no adapter/model, and routes without approving or
+ * persisting anything. Missing backing degrades to inert, never a thrown error or a
+ * fabricated pass/fail.
+ *
+ * Behaviour is built up across the user stories: the schema-invalid short-circuit and
+ * the input-contract branch (T021), the structural rules (US1), the externally-backed
+ * rules (US3), routing (US4), and patch projection (US5).
+ */
+
+import type { Adr, Finding } from '@adrkit/core';
+import { RULE_IDS, type RuleId } from './catalog.ts';
+import { notEvaluated } from './rules/kernel.ts';
+import { acceptedRecordsExcludingCandidate, type RuleContext } from './rules/context.ts';
+import { evaluateSchemaValid } from './rules/schema-valid.ts';
+import { evaluateIdUnique } from './rules/id-unique.ts';
+import { evaluateSupersessionConsistent } from './rules/supersession-consistent.ts';
+import { evaluateNoOrphanRefs } from './rules/no-orphan-refs.ts';
+import { evaluateAffectsResolvable } from './rules/affects-resolvable.ts';
+import { evaluateAffectsOverlap } from './rules/affects-overlap.ts';
+import { evaluateScopeHierarchy } from './rules/scope-hierarchy.ts';
+import { evaluateAssertionsCompile } from './rules/assertions-compile.ts';
+import { evaluateAssertionsPass } from './rules/assertions-pass.ts';
+import { computeAssertionOutcomes } from './assertions/evaluate.ts';
+import { evaluateDeciderResolvable } from './rules/decider-resolvable.ts';
+import { evaluateExpirySane } from './rules/expiry-sane.ts';
+import { assembleReport } from './report/assemble.ts';
+import { computeRouting, notRequiredRouting } from './routing/route.ts';
+import { contradictsAcceptedAdr } from './routing/accepted-assertion.ts';
+import { resolveRecordTargets } from './targets/canonical.ts';
+import { projectPatch } from './patch/project.ts';
+import type {
+  Pass0Evaluation,
+  Pass0Input,
+  Pass0InputContractError,
+  ProposalResolution,
+  RuleResult,
+} from './types.ts';
+
+const PROPOSAL_STATUSES: ReadonlySet<string> = new Set(['draft', 'proposed']);
+const NON_PROPOSAL_STATUSES: ReadonlySet<string> = new Set([
+  'accepted',
+  'rejected',
+  'superseded',
+  'deprecated',
+]);
+
+/** Locate + type the proposal within the corpus (data-model §3). */
+function resolveProposal(input: Pass0Input): ProposalResolution {
+  const proposed = input.corpus.records.find((record) => record.path === input.proposalPath);
+  if (proposed) {
+    return { proposalPath: input.proposalPath, schemaFindings: [], proposed };
+  }
+  const onPath = input.corpus.findings.filter((finding) => finding.path === input.proposalPath);
+  const schemaFindings: readonly Finding[] =
+    onPath.length > 0
+      ? onPath
+      : [
+          {
+            rule: 'file-read',
+            severity: 'error',
+            message: `Proposal not found in corpus: ${input.proposalPath}`,
+            path: input.proposalPath,
+          },
+        ];
+  return { proposalPath: input.proposalPath, schemaFindings };
+}
+
+/** The ten non-schema rules, in fixed order, evaluated over a valid proposal. */
+function evaluateStructuralAndBacked(context: RuleContext): Map<RuleId, RuleResult> {
+  const results = new Map<RuleId, RuleResult>();
+  results.set('id-unique', evaluateIdUnique(context));
+  results.set('supersession-consistent', evaluateSupersessionConsistent(context));
+  results.set('no-orphan-refs', evaluateNoOrphanRefs(context));
+  results.set('affects-resolvable', evaluateAffectsResolvable(context));
+  results.set('affects-overlap', evaluateAffectsOverlap(context));
+  results.set('scope-hierarchy', evaluateScopeHierarchy(context));
+
+  const assertionOutcomes = computeAssertionOutcomes(context);
+  const compile = evaluateAssertionsCompile(assertionOutcomes);
+  results.set('assertions-compile', compile);
+  // Only assertions-pass depends on assertions-compile; a compile failure makes it
+  // not-evaluated.prereq-failed (C11). All other rules continue after a non-schema error.
+  // The shared `assertionOutcomes` guarantees each assertion is compiled exactly once.
+  results.set(
+    'assertions-pass',
+    compile.status === 'fail'
+      ? notEvaluated('assertions-pass', 'not-evaluated.prereq-failed')
+      : evaluateAssertionsPass(assertionOutcomes),
+  );
+
+  results.set('decider-resolvable', evaluateDeciderResolvable(context));
+  results.set('expiry-sane', evaluateExpirySane(context));
+  return results;
+}
+
+/**
+ * Evaluate a proposal under Pass 0. Total: returns either a typed input-contract error
+ * (no report/patch) or an evaluated `{ report, patch }`.
+ */
+export function evaluatePass0(input: Pass0Input): Pass0Evaluation {
+  const resolution = resolveProposal(input);
+
+  // Input-contract precondition: a schema-valid non-draft/proposed record is not a
+  // proposal (candidate-status-not-proposal). No report/patch; CLI maps this to exit 2.
+  if (resolution.proposed) {
+    const status = resolution.proposed.frontmatter.status;
+    if (!PROPOSAL_STATUSES.has(status) && NON_PROPOSAL_STATUSES.has(status)) {
+      const error: Pass0InputContractError = {
+        code: 'candidate-status-not-proposal',
+        proposalPath: input.proposalPath,
+        actualStatus: status as Pass0InputContractError['actualStatus'],
+      };
+      return { kind: 'input-error', error };
+    }
+  }
+
+  const schemaValid = evaluateSchemaValid(resolution);
+  const resultsByRule = new Map<RuleId, RuleResult>();
+  resultsByRule.set('schema-valid', schemaValid);
+
+  if (schemaValid.status === 'fail' || !resolution.proposed) {
+    // Schema-invalid short-circuit: schema-valid fail + ten not-evaluated (C11).
+    for (const rule of RULE_IDS) {
+      if (rule === 'schema-valid') continue;
+      resultsByRule.set(rule, notEvaluated(rule, 'not-evaluated.schema-invalid'));
+    }
+    const report = assembleReport(input.proposalPath, resultsByRule, notRequiredRouting());
+    return { kind: 'evaluated', result: { report, patch: projectPatch(report) } };
+  }
+
+  const proposed: Adr = resolution.proposed;
+  const context: RuleContext = {
+    input,
+    proposed,
+    resolution,
+    corpusRecords: input.corpus.records,
+    acceptedRecords: acceptedRecordsExcludingCandidate(input.corpus.records, input.proposalPath),
+    evaluationDate: input.evaluationDate,
+  };
+
+  for (const [rule, result] of evaluateStructuralAndBacked(context)) {
+    resultsByRule.set(rule, result);
+  }
+
+  // Routing is computed after the eleven rules (R10). The proposal's canonical target
+  // set is resolved once and shared by the trigger checks and named-human resolution.
+  const proposalTargets = resolveRecordTargets(
+    proposed,
+    input.targetRegistry,
+    input.targets,
+    input.resolutionLog,
+  );
+  const contradicts = contradictsAcceptedAdr(context, proposalTargets.targetKeys);
+  const routing = computeRouting(context, proposalTargets, contradicts);
+
+  const report = assembleReport(input.proposalPath, resultsByRule, routing);
+  return { kind: 'evaluated', result: { report, patch: projectPatch(report) } };
+}

package/src/patch/project.ts

@@ -0,0 +1,51 @@
+/**
+ * @adrkit/evaluator — schema-compatible patch projection (§9, R8/R12, T052).
+ *
+ * Projects the eleven rule results down to the committed four-field
+ * `DeterministicFinding` shape — VIOLATIONS ONLY (rule failures at their fixed
+ * severity) — plus `escalate` and existing-enum `escalationReasons` in fixed trigger
+ * order. It strips every operational-only field (reason codes, canonical target ids,
+ * source refs, snapshot ids, candidate/related refs, recordPath, lower-level evidence):
+ * that richness stays on `Pass0Report`. `adr` is copied only when it validates strictly
+ * as a core `AdrRef`, so a filesystem path can never be reinterpreted as an ADR
+ * reference. The evaluator RETURNS the patch; it never writes any record, review state,
+ * database, or index.
+ */
+
+import { AdrRef, type DeterministicFinding } from '@adrkit/core';
+import { RULE_SEVERITY } from '../catalog.ts';
+import type { EvaluationPatch, Pass0Report, RuleFinding, RuleResult } from '../types.ts';
+
+/** A rule result is a violation iff it failed at its fixed severity. */
+export function isViolation(result: RuleResult): boolean {
+  return result.status === 'fail';
+}
+
+function representativeFinding(result: RuleResult): RuleFinding | undefined {
+  // Prefer the finding carrying the aggregate's primary (winning) reason; fall back to
+  // the first sorted finding. Both are deterministic.
+  return result.findings.find((finding) => finding.reason === result.reason) ?? result.findings[0];
+}
+
+/** Project one violating rule result into the committed DeterministicFinding shape. */
+export function projectFinding(result: RuleResult): DeterministicFinding {
+  const finding = representativeFinding(result);
+  const adr = finding?.adr !== undefined && AdrRef.safeParse(finding.adr).success ? finding.adr : undefined;
+  return {
+    rule: result.rule,
+    severity: RULE_SEVERITY[result.rule],
+    ...(finding?.message ? { message: finding.message } : {}),
+    ...(adr !== undefined ? { adr } : {}),
+  };
+}
+
+export function projectPatch(report: Pass0Report): EvaluationPatch {
+  // One DeterministicFinding per violating rule (rubric-id mapping, no duplicate
+  // lower-level findings). Results are already in fixed rubric order.
+  const deterministicFindings = report.results.filter(isViolation).map(projectFinding);
+  return {
+    deterministicFindings,
+    escalate: report.routing.escalate,
+    escalationReasons: report.routing.reasons, // already in fixed trigger order
+  };
+}

package/src/report/aggregate.ts

@@ -0,0 +1,59 @@
+/**
+ * @adrkit/evaluator — deterministic finding aggregation (T026, C11).
+ *
+ * A rule may make several observations but yields exactly one aggregate `RuleResult`.
+ * Status precedence is `fail > inert > pass`; `not-evaluated` is set only by the
+ * orchestrator (schema-invalid or `assertions-pass` after a compile failure). The
+ * aggregate `reason` is the first code, in the rule's fixed catalog precedence, among
+ * the winning-status sub-findings — so mixed fail/inert fixtures are byte-stable
+ * rather than discovery-order dependent. All sub-findings are retained and sorted by
+ * the stable secondary comparator.
+ */
+
+import type { Severity } from '@adrkit/core';
+import { RULE_REASON_PRECEDENCE, RULE_SEVERITY, type ReasonCode, type RuleId } from '../catalog.ts';
+import type { RuleEvidence, RuleFinding, RuleResult } from '../types.ts';
+import { sortRuleFindings } from './order.ts';
+
+/** One underlying observation a rule makes; aggregated into a single RuleResult. */
+export interface SubResult {
+  readonly status: 'pass' | 'fail' | 'inert';
+  readonly reason: ReasonCode;
+  readonly finding?: RuleFinding;
+}
+
+const STATUS_RANK: Record<'pass' | 'fail' | 'inert', number> = { fail: 3, inert: 2, pass: 1 };
+
+function winningStatus(subs: readonly SubResult[]): 'pass' | 'fail' | 'inert' {
+  let winner: 'pass' | 'fail' | 'inert' = 'pass';
+  for (const sub of subs) {
+    if (STATUS_RANK[sub.status] > STATUS_RANK[winner]) winner = sub.status;
+  }
+  return winner;
+}
+
+function primaryReason(rule: RuleId, winners: readonly SubResult[]): ReasonCode {
+  const present = new Set<ReasonCode>(winners.map((sub) => sub.reason));
+  for (const code of RULE_REASON_PRECEDENCE[rule]) {
+    if (present.has(code)) return code;
+  }
+  return RULE_REASON_PRECEDENCE[rule][0] as ReasonCode;
+}
+
+/** Aggregate one rule's sub-results into its single RuleResult (findings sorted). */
+export function aggregate(rule: RuleId, subs: readonly SubResult[], evidence?: RuleEvidence): RuleResult {
+  const status: 'pass' | 'fail' | 'inert' = subs.length === 0 ? 'pass' : winningStatus(subs);
+  const winners = subs.filter((sub) => sub.status === status);
+  const reason =
+    winners.length === 0 ? (RULE_REASON_PRECEDENCE[rule][0] as ReasonCode) : primaryReason(rule, winners);
+  const findings = sortRuleFindings(subs.flatMap((sub) => (sub.finding ? [sub.finding] : [])));
+  const severity: Severity | undefined = status === 'fail' ? RULE_SEVERITY[rule] : undefined;
+  return {
+    rule,
+    status,
+    ...(severity ? { severity } : {}),
+    reason,
+    findings,
+    ...(evidence ? { evidence } : {}),
+  };
+}

package/src/report/assemble.ts

@@ -0,0 +1,43 @@
+/**
+ * @adrkit/evaluator — report assembly.
+ *
+ * Places the eleven RuleResults in fixed rubric order, appends the routing decision
+ * (never a twelfth rule), and computes `outcome`. Secondary finding ordering and
+ * canonical byte serialization are added in US2 (T027/T028).
+ */
+
+import { RULE_IDS, RUBRIC_VERSION, type RuleId } from '../catalog.ts';
+import type { Pass0Report, RoutingDecision, RuleResult } from '../types.ts';
+
+/** `returned` iff any rule failed at `error` severity; otherwise `ok`. */
+export function computeOutcome(results: readonly RuleResult[]): 'ok' | 'returned' {
+  const returned = results.some(
+    (result) => result.status === 'fail' && result.severity === 'error',
+  );
+  return returned ? 'returned' : 'ok';
+}
+
+/**
+ * Assemble the report from a rule→result map. Exactly eleven results are emitted in
+ * fixed rubric order (C11); a missing rule is a programming error.
+ */
+export function assembleReport(
+  proposalPath: string,
+  resultsByRule: ReadonlyMap<RuleId, RuleResult>,
+  routing: RoutingDecision,
+): Pass0Report {
+  const results: RuleResult[] = RULE_IDS.map((rule) => {
+    const result = resultsByRule.get(rule);
+    if (!result) {
+      throw new Error(`internal: missing rule result for "${rule}"`);
+    }
+    return result;
+  });
+  return {
+    rubricVersion: RUBRIC_VERSION,
+    proposalPath,
+    results,
+    routing,
+    outcome: computeOutcome(results),
+  };
+}

package/src/report/order.ts

@@ -0,0 +1,53 @@
+/**
+ * @adrkit/evaluator — deterministic ordering (R11).
+ *
+ * Stable secondary comparators for `RuleFinding`s within a rule and for the patch's
+ * `deterministicFindings`. Precedence (data-model §5/§7): candidate `AdrRef`, related
+ * `AdrRef`, matcher/assertion key, canonical target key, `recordPath`, `field`,
+ * `message`. `RuleFinding.adr` is strictly an `AdrRef`; a path never enters this order
+ * as `adr`. The eleven rule results keep fixed rubric order and routing keeps trigger
+ * order — those arrays are never sorted.
+ */
+
+import { RULE_IDS, type RuleId } from '../catalog.ts';
+import { canonicalTargetKey } from '../keys.ts';
+import { byCodeUnit } from '../compare.ts';
+import type { CanonicalTargetId, RuleFinding } from '../types.ts';
+
+function cmp(a: string | undefined, b: string | undefined): number {
+  return byCodeUnit(a ?? '', b ?? '');
+}
+
+function targetKey(target: CanonicalTargetId | undefined): string {
+  return target ? canonicalTargetKey(target) : '';
+}
+
+/** Stable secondary comparator for RuleFindings within a single rule. */
+export function compareRuleFindings(a: RuleFinding, b: RuleFinding): number {
+  return (
+    cmp(a.candidateAdr, b.candidateAdr) ||
+    cmp(a.relatedAdr, b.relatedAdr) ||
+    cmp(a.matcherKey ?? a.assertionKey, b.matcherKey ?? b.assertionKey) ||
+    cmp(targetKey(a.target), targetKey(b.target)) ||
+    cmp(a.recordPath, b.recordPath) ||
+    cmp(a.field, b.field) ||
+    cmp(a.adr, b.adr) ||
+    cmp(a.message, b.message)
+  );
+}
+
+export function sortRuleFindings(findings: readonly RuleFinding[]): RuleFinding[] {
+  return [...findings].sort(compareRuleFindings);
+}
+
+const RULE_INDEX: ReadonlyMap<RuleId, number> = new Map(RULE_IDS.map((rule, index) => [rule, index]));
+
+/** Index of a rule in the fixed rubric order (for assembly). */
+export function ruleIndex(rule: RuleId): number {
+  return RULE_INDEX.get(rule) ?? RULE_IDS.length;
+}
+
+/** Comparator for a set-like array of canonical target ids (evidence). */
+export function compareCanonicalTargetIds(a: CanonicalTargetId, b: CanonicalTargetId): number {
+  return byCodeUnit(canonicalTargetKey(a), canonicalTargetKey(b));
+}

package/src/report/serialize.ts

@@ -0,0 +1,152 @@
+/**
+ * @adrkit/evaluator — canonical serialization (T028, R11).
+ *
+ * Produces byte-reproducible `report` and `patch` bytes. Serialization is a hand-written
+ * ITERATIVE emitter (no recursion, no `JSON.stringify` key reordering) so that:
+ *   - object keys are emitted in strict code-unit order — including integer-like keys
+ *     (`{"2":..,"10":..}` ⇒ `{"10":..,"2":..}`), which `JSON.stringify` would reorder
+ *     numerically (finding #7);
+ *   - EVERY own JSON key is retained and emitted, including `__proto__`/`constructor`
+ *     smuggled through a null-prototype parse (finding #1); and
+ *   - hostile deep input cannot overflow the stack (finding #5) — the emitter uses an
+ *     explicit work stack, and untrusted data is depth/node-bounded by `withinJsonLimits`
+ *     before it ever reaches here.
+ *
+ * The deterministic payload carries NO timestamp, run id, or duration — caller
+ * `runMetadata` lives in the envelope, outside these bytes (FR-005).
+ */
+
+import { byCodeUnit } from '../compare.ts';
+import type { EvaluationPatch, Pass0Report } from '../types.ts';
+
+type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
+
+type EmitTask = { readonly kind: 'str'; readonly text: string } | { readonly kind: 'val'; readonly value: unknown; readonly depth: number };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function indentOf(depth: number, pretty: boolean): string {
+  return pretty ? '  '.repeat(depth) : '';
+}
+
+/**
+ * Canonical JSON string with keys in code-unit order. `pretty` matches
+ * `JSON.stringify(x, null, 2)` formatting exactly (2-space indent, `": "`, LF).
+ */
+export function canonicalStringify(root: unknown, pretty = false): string {
+  const nl = pretty ? '\n' : '';
+  const colon = pretty ? ': ' : ':';
+  const out: string[] = [];
+  const stack: EmitTask[] = [{ kind: 'val', value: root, depth: 0 }];
+
+  while (stack.length > 0) {
+    const task = stack.pop();
+    if (!task) continue;
+    if (task.kind === 'str') {
+      out.push(task.text);
+      continue;
+    }
+    const { value, depth } = task;
+    if (value === null) {
+      out.push('null');
+      continue;
+    }
+    const type = typeof value;
+    if (type === 'string' || type === 'boolean') {
+      out.push(JSON.stringify(value));
+      continue;
+    }
+    if (type === 'number') {
+      // Only finite numbers are valid JSON; a non-finite slips through as null.
+      out.push(Number.isFinite(value) ? JSON.stringify(value) : 'null');
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        out.push('[]');
+        continue;
+      }
+      const parts: EmitTask[] = [{ kind: 'str', text: `[${nl}` }];
+      value.forEach((item, i) => {
+        parts.push({ kind: 'str', text: indentOf(depth + 1, pretty) });
+        parts.push({ kind: 'val', value: item, depth: depth + 1 });
+        parts.push({ kind: 'str', text: `${i < value.length - 1 ? ',' : ''}${nl}` });
+      });
+      parts.push({ kind: 'str', text: `${indentOf(depth, pretty)}]` });
+      for (let i = parts.length - 1; i >= 0; i -= 1) stack.push(parts[i] as EmitTask);
+      continue;
+    }
+    if (isRecord(value)) {
+      const source = value;
+      // Own enumerable keys (null-prototype dictionaries keep __proto__/constructor as
+      // own keys), sorted deterministically by code unit; undefined values are omitted.
+      const keys = Object.keys(source)
+        .filter((key) => source[key] !== undefined)
+        .sort(byCodeUnit);
+      if (keys.length === 0) {
+        out.push('{}');
+        continue;
+      }
+      const parts: EmitTask[] = [{ kind: 'str', text: `{${nl}` }];
+      keys.forEach((key, i) => {
+        parts.push({ kind: 'str', text: `${indentOf(depth + 1, pretty)}${JSON.stringify(key)}${colon}` });
+        parts.push({ kind: 'val', value: source[key], depth: depth + 1 });
+        parts.push({ kind: 'str', text: `${i < keys.length - 1 ? ',' : ''}${nl}` });
+      });
+      parts.push({ kind: 'str', text: `${indentOf(depth, pretty)}}` });
+      for (let i = parts.length - 1; i >= 0; i -= 1) stack.push(parts[i] as EmitTask);
+      continue;
+    }
+    // Non-JSON (function/symbol/undefined) — defensively emit null. Validated inputs
+    // never reach this branch.
+    out.push('null');
+  }
+  return out.join('');
+}
+
+/**
+ * Canonical JS structure with keys recursively sorted (code unit) — used for structural
+ * equality comparisons and CLI envelope building, NOT for byte emission. Output objects
+ * are null-prototype so a smuggled `__proto__` own key is retained rather than dropped.
+ */
+export function canonicalize(value: unknown): Json {
+  if (value === null) return null;
+  if (typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item));
+  }
+  if (!isRecord(value)) return null;
+  const source = value;
+  const out: { [key: string]: Json } = Object.create(null) as { [key: string]: Json };
+  for (const key of Object.keys(source).sort(byCodeUnit)) {
+    const entry = source[key];
+    if (entry === undefined) continue;
+    out[key] = canonicalize(entry);
+  }
+  return out;
+}
+
+/** Canonical JSON bytes: code-unit-sorted keys, 2-space indent, single trailing LF. */
+export function canonicalBytes(value: unknown): string {
+  return `${canonicalStringify(value, true)}\n`;
+}
+
+export function serializeReport(report: Pass0Report): string {
+  return canonicalBytes(report);
+}
+
+export function serializePatch(patch: EvaluationPatch): string {
+  return canonicalBytes(patch);
+}
+
+export interface CanonicalArtifacts {
+  readonly report: string;
+  readonly patch: string;
+}
+
+export function serializeArtifacts(report: Pass0Report, patch: EvaluationPatch): CanonicalArtifacts {
+  return { report: serializeReport(report), patch: serializePatch(patch) };
+}

package/src/routing/accepted-assertion.ts

@@ -0,0 +1,39 @@
+/**
+ * @adrkit/evaluator — accepted-ADR assertion routing evidence (T048, C4).
+ *
+ * The `contradicts-accepted-adr` trigger is proven when the proposal canonically
+ * overlaps an accepted ADR (rule 6) AND an assertion on that overlapping accepted ADR
+ * FAILS against the supplied proposed / current-HEAD input. Unlike `scope-hierarchy`,
+ * this does NOT require org scope, domain applicability, or a base-green transition —
+ * only the proposed-side failure. Pure; reuses the same engine registry.
+ */
+
+import { compileAssertionForScope } from '../assertions/evaluate.ts';
+import { makeAssertionKey } from '../keys.ts';
+import { resolveRecordTargets } from '../targets/canonical.ts';
+import type { RuleContext } from '../rules/context.ts';
+import type { CanonicalTargetKey } from '../types.ts';
+
+export function contradictsAcceptedAdr(
+  ctx: RuleContext,
+  proposalTargetKeys: ReadonlySet<CanonicalTargetKey>,
+): boolean {
+  if (proposalTargetKeys.size === 0) return false;
+
+  for (const accepted of ctx.acceptedRecords) {
+    const acceptedTargets = resolveRecordTargets(accepted, ctx.input.targetRegistry, ctx.input.targets, ctx.input.resolutionLog);
+    const overlaps = [...proposalTargetKeys].some((key) => acceptedTargets.targetKeys.has(key));
+    if (!overlaps) continue;
+
+    for (const assertion of accepted.frontmatter.assertions) {
+      const key = makeAssertionKey(accepted.log, accepted.path, assertion.id);
+      const compiled = compileAssertionForScope(ctx, accepted, assertion);
+      if (!compiled.ok) continue;
+      const proposedInput = ctx.input.assertionInputs.inputs[key]?.document;
+      if (proposedInput === undefined) continue;
+      const evaluated = compiled.evaluate(proposedInput);
+      if (evaluated.ok && !evaluated.pass) return true;
+    }
+  }
+  return false;
+}

package/src/routing/route.ts

@@ -0,0 +1,105 @@
+/**
+ * @adrkit/evaluator — escalation routing (T046, R10/C4/C7).
+ *
+ * A declarative OR over the eight deterministically-proven Pass 0 triggers, computed
+ * AFTER the eleven rule results (never a twelfth rule). Each trigger emits an ordered
+ * proven/not-proven evidence status; missing optional evidence is "not-proven", never a
+ * fabricated escalation. When escalation is proven, a single active human is resolved
+ * (deciders -> CODEOWNERS -> catalog); otherwise the target is `not-required`.
+ */
+
+import {
+  ROUTE_ESCALATE_CODE,
+  ROUTE_EVIDENCE_NOT_PROVEN_CODE,
+  ROUTING_TRIGGERS,
+  type Pass0EscalationReason,
+} from '../catalog.ts';
+import { buildIdentityIndex } from '../identity/directory.ts';
+import type { RuleContext } from '../rules/context.ts';
+import type { RecordTargetResolution } from '../targets/canonical.ts';
+import { resolveRouteTarget } from './target.ts';
+import type { CanonicalTargetKey, RoutingDecision, TriggerEvidenceStatus } from '../types.ts';
+
+/** All eight triggers as `not-proven`, in fixed order (used for schema-invalid reports). */
+export function allNotProven(): readonly TriggerEvidenceStatus[] {
+  return ROUTING_TRIGGERS.map(
+    (reason: Pass0EscalationReason): TriggerEvidenceStatus => ({
+      reason,
+      status: 'not-proven',
+      code: ROUTE_EVIDENCE_NOT_PROVEN_CODE[reason],
+    }),
+  );
+}
+
+/** The deterministic non-escalated routing decision (schema-invalid short-circuit). */
+export function notRequiredRouting(): RoutingDecision {
+  return {
+    escalate: false,
+    reasons: [],
+    evidenceStatus: allNotProven(),
+    target: { kind: 'not-required', code: 'route.target.not-required' },
+  };
+}
+
+function intersects(a: ReadonlySet<CanonicalTargetKey>, b: ReadonlySet<CanonicalTargetKey> | undefined): boolean {
+  if (!b || b.size === 0) return false;
+  for (const key of a) if (b.has(key)) return true;
+  return false;
+}
+
+/** Evaluate the eight triggers and resolve the target if escalation is proven. */
+export function computeRouting(
+  ctx: RuleContext,
+  proposalTargets: RecordTargetResolution,
+  contradictsAccepted: boolean,
+): RoutingDecision {
+  const evidence = ctx.input.routingEvidence;
+  const proposalKeys = proposalTargets.targetKeys;
+  const frontmatter = ctx.proposed.frontmatter;
+
+  const proven: Record<Pass0EscalationReason, boolean> = {
+    'one-way-door': frontmatter.reversibility === 'one-way-door',
+    'cost-threshold':
+      evidence?.costEvidence !== undefined && evidence.costEvidence.normalizedCost >= evidence.costEvidence.threshold,
+    'security-surface': intersects(proposalKeys, evidence?.securitySurfaceTargets),
+    'data-residency': evidence?.dataResidency?.present === true,
+    regulatory: frontmatter.complianceControls.length > 0 || intersects(proposalKeys, evidence?.regulatedTargets),
+    'contradicts-accepted-adr': contradictsAccepted,
+    'agent-authored-production':
+      (frontmatter.provenance?.authoredBy === 'agent' || frontmatter.provenance?.authoredBy === 'agent-drafted') &&
+      intersects(proposalKeys, evidence?.productionTargets),
+    'human-requested': evidence?.humanRequested?.requester !== undefined,
+  };
+
+  const evidenceStatus: TriggerEvidenceStatus[] = ROUTING_TRIGGERS.map((reason) =>
+    proven[reason]
+      ? { reason, status: 'proven', code: ROUTE_ESCALATE_CODE[reason] }
+      : { reason, status: 'not-proven', code: ROUTE_EVIDENCE_NOT_PROVEN_CODE[reason] },
+  );
+  const reasons = ROUTING_TRIGGERS.filter((reason) => proven[reason]);
+  const escalate = reasons.length > 0;
+
+  if (!escalate) {
+    return {
+      escalate: false,
+      reasons: [],
+      evidenceStatus,
+      target: { kind: 'not-required', code: 'route.target.not-required' },
+    };
+  }
+
+  const directory = ctx.input.identity;
+  if (!directory) {
+    return { escalate: true, reasons, evidenceStatus, target: { kind: 'unresolved', code: 'route.target.unresolved' } };
+  }
+  const resolvedPaths = proposalTargets.targets.filter((id) => id.kind === 'path').map((id) => id.id);
+  const resolvedEntities = proposalTargets.targets.filter((id) => id.kind === 'entity');
+  const target = resolveRouteTarget(
+    buildIdentityIndex(directory),
+    frontmatter.deciders,
+    directory,
+    resolvedPaths,
+    resolvedEntities,
+  );
+  return { escalate: true, reasons, evidenceStatus, target };
+}