@adrkit/evaluator 0.1.0

package/src/routing/target.ts

@@ -0,0 +1,104 @@
+/**
+ * @adrkit/evaluator — named-human routing target (T047, R9/C7).
+ *
+ * Resolves a single active human in fixed source order: (1) proposal `deciders`, (2)
+ * CODEOWNERS owners for the proposal's resolved paths, (3) catalog owners for its
+ * resolved entities. Exact source-local ordering: deciders in declaration order; unique
+ * paths sorted by canonical path key, each taking the LAST matching CODEOWNERS rule's
+ * owners in declaration order; unique entities sorted by canonical target key, each
+ * appending catalog owners in snapshot order. Candidates are stable-deduplicated at
+ * first occurrence (never globally identity-sorted). A missing/inactive direct human is
+ * skipped; the first team that does not resolve to exactly one active human is an
+ * ambiguity barrier that immediately yields `unresolved`.
+ */
+
+import { matchPathPattern } from '@adrkit/core';
+import { canonicalTargetKey } from '../keys.ts';
+import { byCodeUnit } from '../compare.ts';
+import type { IdentityIndex } from '../identity/directory.ts';
+import type { CanonicalTargetId, IdentityDirectorySnapshot, PrincipalRef, RouteTarget } from '../types.ts';
+
+type Via = 'deciders' | 'codeowners' | 'catalog';
+
+interface Candidate {
+  readonly ref: PrincipalRef;
+  readonly via: Via;
+}
+
+const VIA_CODE: Record<Via, 'route.target.deciders' | 'route.target.codeowners' | 'route.target.catalog-owner'> = {
+  deciders: 'route.target.deciders',
+  codeowners: 'route.target.codeowners',
+  catalog: 'route.target.catalog-owner',
+};
+
+function orderedCandidates(
+  deciders: readonly PrincipalRef[],
+  directory: IdentityDirectorySnapshot,
+  resolvedPaths: readonly string[],
+  resolvedEntities: readonly CanonicalTargetId[],
+): Candidate[] {
+  const candidates: Candidate[] = [];
+
+  // (1) deciders in declaration order
+  for (const decider of deciders) candidates.push({ ref: decider, via: 'deciders' });
+
+  // (2) CODEOWNERS for unique resolved paths sorted by canonical path key
+  const codeowners = directory.codeowners ?? [];
+  const uniquePaths = [...new Set(resolvedPaths)].sort(byCodeUnit);
+  for (const path of uniquePaths) {
+    let lastMatch: readonly PrincipalRef[] | undefined;
+    for (const rule of codeowners) {
+      if (matchPathPattern(rule.pattern, [path]).matched) lastMatch = rule.owners;
+    }
+    if (lastMatch) {
+      for (const owner of lastMatch) candidates.push({ ref: owner, via: 'codeowners' });
+    }
+  }
+
+  // (3) catalog owners for unique resolved entities sorted by canonical target key
+  const catalogOwners = directory.catalogOwners;
+  const uniqueEntities = [...new Map(resolvedEntities.map((id) => [canonicalTargetKey(id), id])).values()].sort((a, b) =>
+    byCodeUnit(canonicalTargetKey(a), canonicalTargetKey(b)),
+  );
+  for (const entity of uniqueEntities) {
+    const owners =
+      catalogOwners !== undefined && Object.hasOwn(catalogOwners, entity.id)
+        ? catalogOwners[entity.id] ?? []
+        : [];
+    for (const owner of owners) candidates.push({ ref: owner, via: 'catalog' });
+  }
+
+  return candidates;
+}
+
+/**
+ * Resolve the escalation target. Called only when escalation is proven; a non-escalated
+ * run uses `route.target.not-required` at the routing layer.
+ */
+export function resolveRouteTarget(
+  index: IdentityIndex,
+  deciders: readonly PrincipalRef[],
+  directory: IdentityDirectorySnapshot,
+  resolvedPaths: readonly string[],
+  resolvedEntities: readonly CanonicalTargetId[],
+): RouteTarget {
+  const candidates = orderedCandidates(deciders, directory, resolvedPaths, resolvedEntities);
+  const seen = new Set<PrincipalRef>();
+
+  for (const candidate of candidates) {
+    if (seen.has(candidate.ref)) continue; // stable dedupe at first occurrence
+    seen.add(candidate.ref);
+
+    const resolution = index.resolveToActiveHuman(candidate.ref);
+    if (resolution.status === 'resolved') {
+      return { kind: 'resolved', human: resolution.human, via: candidate.via, code: VIA_CODE[candidate.via] };
+    }
+    // A team that does not resolve to exactly one active human is an ambiguity barrier.
+    if (index.isTeam(candidate.ref)) {
+      return { kind: 'unresolved', code: 'route.target.unresolved' };
+    }
+    // Otherwise a missing/inactive direct human is skipped.
+  }
+
+  return { kind: 'unresolved', code: 'route.target.unresolved' };
+}

package/src/rules/affects-overlap.ts

@@ -0,0 +1,55 @@
+/**
+ * @adrkit/evaluator — rule 6: affects-overlap (warn).
+ *
+ * Finite canonical-target-key intersection of the proposal with each ACCEPTED ADR,
+ * computed once per (proposal, accepted-ADR) pair (R4). Primary precedence (§3.1):
+ * any non-empty intersection ⇒ warn (`accepted-intersection`); otherwise no accepted
+ * ADRs ⇒ pass (`no-accepted-corpus`); otherwise absent required pair backing ⇒ inert
+ * (`backing-absent`); otherwise a fully evaluated accepted corpus with no intersection
+ * ⇒ pass (`none`).
+ */
+
+import { aggregate, inertResult, passResult, type SubResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import { anyMatcherInert, resolveRecordTargets } from '../targets/canonical.ts';
+import { byCodeUnit } from '../compare.ts';
+import type { RuleResult } from '../types.ts';
+
+export function evaluateAffectsOverlap(ctx: RuleContext): RuleResult {
+  const accepted = ctx.acceptedRecords;
+  if (accepted.length === 0) {
+    return passResult('affects-overlap', 'affects-overlap.no-accepted-corpus');
+  }
+
+  const proposal = resolveRecordTargets(ctx.proposed, ctx.input.targetRegistry, ctx.input.targets, ctx.input.resolutionLog);
+  let anyInert = anyMatcherInert(proposal);
+  const subs: SubResult[] = [];
+  const overlapping: string[] = [];
+
+  for (const acc of accepted) {
+    const accResolution = resolveRecordTargets(acc, ctx.input.targetRegistry, ctx.input.targets, ctx.input.resolutionLog);
+    if (anyMatcherInert(accResolution)) anyInert = true;
+    const intersects = [...proposal.targetKeys].some((key) => accResolution.targetKeys.has(key));
+    if (intersects) {
+      overlapping.push(acc.frontmatter.id);
+      subs.push({
+        status: 'fail',
+        reason: 'affects-overlap.accepted-intersection',
+        finding: {
+          reason: 'affects-overlap.accepted-intersection',
+          candidateAdr: ctx.proposed.frontmatter.id,
+          relatedAdr: acc.frontmatter.id,
+          message: `affects overlaps accepted ADR "${acc.frontmatter.id}"`,
+        },
+      });
+    }
+  }
+
+  if (subs.length > 0) {
+    return aggregate('affects-overlap', subs, { overlappingWith: [...overlapping].sort(byCodeUnit) });
+  }
+  if (anyInert) {
+    return inertResult('affects-overlap', 'affects-overlap.backing-absent');
+  }
+  return passResult('affects-overlap', 'affects-overlap.none');
+}

package/src/rules/affects-resolvable.ts

@@ -0,0 +1,83 @@
+/**
+ * @adrkit/evaluator — rule 5: affects-resolvable (warn).
+ *
+ * Validates EACH proposal matcher independently, not only the union (finding #2): a
+ * matcher that resolves to real targets cannot mask another positive matcher with
+ * present backing that resolves to ZERO. ADR-0009 semantics are preserved — negation
+ * subtracts, and a different-repo qualifier contributes no local match. Per positive
+ * matcher: ≥1 resolved id ⇒ pass; present backing + zero ids ⇒ warn (`zero-targets`);
+ * a missing inventory (`backing-absent`) or resolver (`resolver-absent`) ⇒ inert. A
+ * negation-only record resolves to the empty set ⇒ warn. No affects ⇒ trivially pass.
+ */
+
+import { aggregate, passResult, type SubResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import { resolveRecordTargets } from '../targets/canonical.ts';
+import type { MatcherResolution } from '../targets/canonical.ts';
+import type { RuleFinding, RuleResult } from '../types.ts';
+
+function matcherFinding(ctx: RuleContext, matcher: MatcherResolution, reason: RuleFinding['reason'], message: string): RuleFinding {
+  return {
+    reason,
+    candidateAdr: ctx.proposed.frontmatter.id,
+    matcherKey: `${matcher.type}:${matcher.pattern}`,
+    recordPath: ctx.proposed.path,
+    field: `affects.${matcher.type}`,
+    message,
+  };
+}
+
+export function evaluateAffectsResolvable(ctx: RuleContext): RuleResult {
+  const resolution = resolveRecordTargets(ctx.proposed, ctx.input.targetRegistry, ctx.input.targets, ctx.input.resolutionLog);
+  if (!resolution.hasMatchers) return passResult('affects-resolvable');
+
+  const subs: SubResult[] = [];
+
+  for (const matcher of resolution.matchers) {
+    if (matcher.status === 'inert-resolver') {
+      subs.push({
+        status: 'inert',
+        reason: 'affects-resolvable.resolver-absent',
+        finding: matcherFinding(ctx, matcher, 'affects-resolvable.resolver-absent', `No resolver registered for "${matcher.type}" matcher "${matcher.pattern}"`),
+      });
+      continue;
+    }
+    if (matcher.status === 'inert-backing') {
+      subs.push({
+        status: 'inert',
+        reason: 'affects-resolvable.backing-absent',
+        finding: matcherFinding(ctx, matcher, 'affects-resolvable.backing-absent', `No inventory backing for "${matcher.type}" matcher "${matcher.pattern}"`),
+      });
+      continue;
+    }
+    // resolved (including a different-repo matcher, which resolves empty locally)
+    if (matcher.negate) continue; // negations only subtract; they are not a zero-target warn
+    if (matcher.ids.length >= 1) {
+      subs.push({ status: 'pass', reason: 'affects-resolvable.ok' });
+    } else {
+      subs.push({
+        status: 'fail',
+        reason: 'affects-resolvable.zero-targets',
+        finding: matcherFinding(ctx, matcher, 'affects-resolvable.zero-targets', `"${matcher.type}" matcher "${matcher.pattern}" resolves to zero targets against the supplied inventory`),
+      });
+    }
+  }
+
+  // A record with matchers but NO positive matcher (negation-only) resolves to empty.
+  if (!resolution.hasPositiveMatcher) {
+    subs.push({
+      status: 'fail',
+      reason: 'affects-resolvable.zero-targets',
+      finding: {
+        reason: 'affects-resolvable.zero-targets',
+        candidateAdr: ctx.proposed.frontmatter.id,
+        recordPath: ctx.proposed.path,
+        field: 'affects',
+        message: 'negation-only affects resolves to zero targets',
+      },
+    });
+  }
+
+  if (subs.length === 0) return passResult('affects-resolvable');
+  return aggregate('affects-resolvable', subs, { resolvedTargets: resolution.targets });
+}

package/src/rules/assertions-compile.ts

@@ -0,0 +1,18 @@
+/**
+ * @adrkit/evaluator — rule 8: assertions-compile (error).
+ *
+ * Each assertion declares exactly one source and the approved engine profile validates
+ * it. Neither/both source ⇒ error; a failed source/artifact validation ⇒ error; a
+ * missing engine, resolved file content, or compiled artifact ⇒ inert; no assertions ⇒
+ * pass (`none`). Consumes the shared per-evaluation assertion outcomes so each assertion
+ * is compiled/validated exactly once (R7). One aggregate result.
+ */
+
+import { aggregate, passResult } from './kernel.ts';
+import type { AssertionOutcomes } from '../assertions/evaluate.ts';
+import type { RuleResult } from '../types.ts';
+
+export function evaluateAssertionsCompile(outcomes: AssertionOutcomes): RuleResult {
+  if (!outcomes.hasAssertions) return passResult('assertions-compile', 'assertions-compile.none');
+  return aggregate('assertions-compile', outcomes.compileSubs);
+}

package/src/rules/assertions-pass.ts

@@ -0,0 +1,21 @@
+/**
+ * @adrkit/evaluator — rule 9: assertions-pass (warn).
+ *
+ * Evaluates each compiled assertion against its resolved input. A false result or a
+ * deterministic engine evaluation error ⇒ warn; a missing engine/input ⇒ inert; no
+ * assertions ⇒ pass (`none`). A compile FAILURE makes this whole rule
+ * `not-evaluated.prereq-failed` — enforced by the orchestrator, which only calls this
+ * rule when assertions-compile did not fail. Consumes the shared per-evaluation
+ * outcomes (one compile per assertion). One aggregate result.
+ */
+
+import { aggregate, passResult } from './kernel.ts';
+import type { AssertionOutcomes } from '../assertions/evaluate.ts';
+import type { RuleResult } from '../types.ts';
+
+export function evaluateAssertionsPass(outcomes: AssertionOutcomes): RuleResult {
+  if (!outcomes.hasAssertions || outcomes.passSubs.length === 0) {
+    return passResult('assertions-pass', 'assertions-pass.none');
+  }
+  return aggregate('assertions-pass', outcomes.passSubs);
+}

package/src/rules/context.ts

@@ -0,0 +1,31 @@
+/**
+ * @adrkit/evaluator — per-rule evaluation context.
+ *
+ * Assembled once by the orchestrator after `schema-valid` passes. Rules read only
+ * from this immutable context; none performs I/O.
+ */
+
+import type { Adr } from '@adrkit/core';
+import type { Pass0Input, ProposalResolution } from '../types.ts';
+
+export interface RuleContext {
+  readonly input: Pass0Input;
+  /** The typed proposal (schema-valid passed). */
+  readonly proposed: Adr;
+  readonly resolution: ProposalResolution;
+  /** Full corpus records, INCLUDING the candidate (data-model §2). */
+  readonly corpusRecords: readonly Adr[];
+  /** Accepted ADRs in the corpus, EXCLUDING the candidate. */
+  readonly acceptedRecords: readonly Adr[];
+  readonly evaluationDate: string;
+}
+
+/** Records in the corpus that are accepted and are not the candidate proposal. */
+export function acceptedRecordsExcludingCandidate(
+  records: readonly Adr[],
+  proposalPath: string,
+): readonly Adr[] {
+  return records.filter(
+    (record) => record.frontmatter.status === 'accepted' && record.path !== proposalPath,
+  );
+}

package/src/rules/decider-resolvable.ts

@@ -0,0 +1,55 @@
+/**
+ * @adrkit/evaluator — rule 10: decider-resolvable (warn).
+ *
+ * Every declared proposal decider must resolve through the immutable identity
+ * directory to exactly one active principal (R9). None declared, a zero match, or an
+ * ambiguous match is a warn; an absent directory is inert. Exactly one aggregate result.
+ */
+
+import { aggregate, inertResult, type SubResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import { buildIdentityIndex } from '../identity/directory.ts';
+import type { RuleResult } from '../types.ts';
+
+export function evaluateDeciderResolvable(ctx: RuleContext): RuleResult {
+  const directory = ctx.input.identity;
+  if (!directory) {
+    return inertResult('decider-resolvable', 'decider-resolvable.directory-absent');
+  }
+
+  const deciders = ctx.proposed.frontmatter.deciders;
+  if (deciders.length === 0) {
+    return aggregate('decider-resolvable', [
+      {
+        status: 'fail',
+        reason: 'decider-resolvable.none-declared',
+        finding: {
+          reason: 'decider-resolvable.none-declared',
+          candidateAdr: ctx.proposed.frontmatter.id,
+          field: 'deciders',
+          message: 'No deciders are declared on the proposal',
+        },
+      },
+    ]);
+  }
+
+  const index = buildIdentityIndex(directory);
+  const subs: SubResult[] = deciders.map((decider) => {
+    const resolution = index.resolveToActiveHuman(decider);
+    if (resolution.status === 'resolved') {
+      return { status: 'pass', reason: 'decider-resolvable.ok' };
+    }
+    const reason = resolution.status === 'ambiguous' ? 'decider-resolvable.ambiguous-match' : 'decider-resolvable.zero-match';
+    return {
+      status: 'fail',
+      reason,
+      finding: {
+        reason,
+        candidateAdr: ctx.proposed.frontmatter.id,
+        field: 'deciders',
+        message: `Decider "${decider}" ${resolution.status === 'ambiguous' ? 'resolves ambiguously' : 'does not resolve to one active principal'}`,
+      },
+    };
+  });
+  return aggregate('decider-resolvable', subs);
+}

package/src/rules/expiry-sane.ts

@@ -0,0 +1,30 @@
+/**
+ * @adrkit/evaluator — rule 11: expiry-sane (info).
+ *
+ * `reviewBy` is compared to the caller-supplied `evaluationDate` — NO clock is read.
+ * Absent `reviewBy`, or one strictly after the evaluation date, passes; a `reviewBy`
+ * on or before the evaluation date is `info` (`past-or-equal`). Both are ISO `YYYY-MM-DD`
+ * strings, which compare correctly lexicographically.
+ */
+
+import { aggregate, passResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import type { RuleResult } from '../types.ts';
+
+export function evaluateExpirySane(ctx: RuleContext): RuleResult {
+  const reviewBy = ctx.proposed.frontmatter.reviewBy;
+  if (reviewBy === undefined) return passResult('expiry-sane');
+  if (reviewBy > ctx.evaluationDate) return passResult('expiry-sane');
+  return aggregate('expiry-sane', [
+    {
+      status: 'fail',
+      reason: 'expiry-sane.past-or-equal',
+      finding: {
+        reason: 'expiry-sane.past-or-equal',
+        candidateAdr: ctx.proposed.frontmatter.id,
+        field: 'reviewBy',
+        message: `reviewBy "${reviewBy}" is on or before the evaluation date "${ctx.evaluationDate}"`,
+      },
+    },
+  ]);
+}

package/src/rules/id-unique.ts

@@ -0,0 +1,57 @@
+/**
+ * @adrkit/evaluator — rule 2: id-unique (error).
+ *
+ * Identity is scoped by `[record.log ?? "", id]` over the candidate-inclusive corpus
+ * plus optional federated-log snapshots (T018). A duplicate of the candidate's key
+ * fails (`id-unique.collision`); equal ids in different named logs pass. Exactly one
+ * aggregate result is emitted (C11).
+ */
+
+import type { Adr } from '@adrkit/core';
+import { aggregate, passResult, type SubResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import type { FederatedLogSnapshot, RuleFinding, RuleResult } from '../types.ts';
+
+function key(log: string | undefined, id: string): string {
+  return JSON.stringify([log ?? '', id]);
+}
+
+function corpusKey(record: Adr): string {
+  return key(record.log, record.frontmatter.id);
+}
+
+function federatedKeys(snapshots: readonly FederatedLogSnapshot[] | undefined): string[] {
+  const keys: string[] = [];
+  for (const snapshot of snapshots ?? []) {
+    for (const id of snapshot.adrIds) keys.push(key(snapshot.log, id));
+  }
+  return keys;
+}
+
+export function evaluateIdUnique(ctx: RuleContext): RuleResult {
+  const candidate = key(ctx.proposed.log, ctx.proposed.frontmatter.id);
+
+  let occurrences = 0;
+  for (const record of ctx.corpusRecords) {
+    if (corpusKey(record) === candidate) occurrences += 1;
+  }
+  for (const federated of federatedKeys(ctx.input.federatedLogs)) {
+    if (federated === candidate) occurrences += 1;
+  }
+
+  if (occurrences <= 1) {
+    return passResult('id-unique');
+  }
+
+  const finding: RuleFinding = {
+    reason: 'id-unique.collision',
+    message: `ADR id "${ctx.proposed.frontmatter.id}" is not unique within log "${ctx.proposed.log ?? ''}"`,
+    adr: ctx.proposed.frontmatter.id,
+    candidateAdr: ctx.proposed.frontmatter.id,
+    recordPath: ctx.proposed.path,
+    field: 'id',
+    lowerLevel: { rule: 'unique-id', path: ctx.proposed.path, id: ctx.proposed.frontmatter.id, field: 'id' },
+  };
+  const subs: SubResult[] = [{ status: 'fail', reason: 'id-unique.collision', finding }];
+  return aggregate('id-unique', subs);
+}

package/src/rules/kernel.ts

@@ -0,0 +1,33 @@
+/**
+ * @adrkit/evaluator — rule kernel (result builders).
+ *
+ * Re-exports the canonical aggregation (`report/aggregate.ts`) and provides the small
+ * result builders rules use for clean pass / inert / not-evaluated outcomes. Keeping a
+ * single `aggregate` implementation avoids drift between rules and report assembly.
+ */
+
+import { RULE_REASON_PRECEDENCE, type ReasonCode, type RuleId } from '../catalog.ts';
+import type { RuleFinding, RuleResult } from '../types.ts';
+
+export { aggregate, type SubResult } from '../report/aggregate.ts';
+
+/** A clean pass with no sub-findings, using the rule's `.ok` reason by default. */
+export function passResult(
+  rule: RuleId,
+  reason: ReasonCode = RULE_REASON_PRECEDENCE[rule][0] as ReasonCode,
+): RuleResult {
+  return { rule, status: 'pass', reason, findings: [] };
+}
+
+/** An inert (degraded) result — backing absent, never a violation. */
+export function inertResult(rule: RuleId, reason: ReasonCode, finding?: RuleFinding): RuleResult {
+  return { rule, status: 'inert', reason, findings: finding ? [finding] : [] };
+}
+
+/** A not-evaluated result (schema-invalid short-circuit or prereq-failed only). */
+export function notEvaluated(
+  rule: RuleId,
+  reason: 'not-evaluated.schema-invalid' | 'not-evaluated.prereq-failed',
+): RuleResult {
+  return { rule, status: 'not-evaluated', reason, findings: [] };
+}

package/src/rules/no-orphan-refs.ts

@@ -0,0 +1,102 @@
+/**
+ * @adrkit/evaluator — rule 4: no-orphan-refs (error).
+ *
+ * Local `supersedes` / `relatesTo` targets must resolve. A federated ref (`<log>:<id>`)
+ * resolves against a supplied federated-log snapshot; a federated ref whose log has NO
+ * snapshot is inert (`federated-log-absent`), never an orphan failure (C2). `supersededBy`
+ * is owned by supersession-consistent and is not re-reported here. Exactly one aggregate
+ * result (C11); status precedence keeps a dangling failure above a federated inert.
+ */
+
+import type { Adr } from '@adrkit/core';
+import { aggregate, passResult, type SubResult } from './kernel.ts';
+import type { RuleContext } from './context.ts';
+import type { ReasonCode, RuleFinding, RuleResult } from '../types.ts';
+
+type RefField = 'supersedes' | 'relatesTo';
+
+interface Parsed {
+  readonly log?: string;
+  readonly id: string;
+}
+
+function parseRef(ref: string): Parsed {
+  const idx = ref.indexOf(':');
+  if (idx <= 0) return { id: ref };
+  return { log: ref.slice(0, idx), id: ref.slice(idx + 1) };
+}
+
+export function evaluateNoOrphanRefs(ctx: RuleContext): RuleResult {
+  const resolutionLog = ctx.input.resolutionLog;
+
+  const localIds = new Set<string>();
+  const knownLogs = new Map<string, Set<string>>();
+  for (const record of ctx.corpusRecords) {
+    if (record.log === undefined || record.log === resolutionLog) {
+      localIds.add(record.frontmatter.id);
+    }
+    if (record.log !== undefined) {
+      const set = knownLogs.get(record.log) ?? new Set<string>();
+      set.add(record.frontmatter.id);
+      knownLogs.set(record.log, set);
+    }
+  }
+  for (const snapshot of ctx.input.federatedLogs ?? []) {
+    const set = knownLogs.get(snapshot.log) ?? new Set<string>();
+    for (const id of snapshot.adrIds) set.add(id);
+    knownLogs.set(snapshot.log, set);
+  }
+
+  const subs: SubResult[] = [];
+
+  function classify(ref: string): 'resolved' | 'dangling' | 'federated-absent' {
+    const parsed = parseRef(ref);
+    if (parsed.log === undefined || parsed.log === resolutionLog) {
+      return localIds.has(parsed.id) ? 'resolved' : 'dangling';
+    }
+    const known = knownLogs.get(parsed.log);
+    if (!known) return 'federated-absent';
+    return known.has(parsed.id) ? 'resolved' : 'dangling';
+  }
+
+  function check(record: Adr, field: RefField, refs: readonly string[]): void {
+    const danglingReason: ReasonCode =
+      field === 'supersedes' ? 'no-orphan-refs.dangling-supersedes' : 'no-orphan-refs.dangling-relates-to';
+    const lowerRule = field === 'supersedes' ? 'dangling-supersedes' : 'dangling-relatesTo';
+    for (const ref of refs) {
+      const outcome = classify(ref);
+      if (outcome === 'resolved') continue;
+      if (outcome === 'federated-absent') {
+        const finding: RuleFinding = {
+          reason: 'no-orphan-refs.federated-log-absent',
+          message: `Federated ref "${ref}" has no external-log snapshot; reference is inert`,
+          candidateAdr: record.frontmatter.id,
+          relatedAdr: ref,
+          recordPath: record.path,
+          field,
+        };
+        subs.push({ status: 'inert', reason: 'no-orphan-refs.federated-log-absent', finding });
+        continue;
+      }
+      const finding: RuleFinding = {
+        reason: danglingReason,
+        message: `Reference "${ref}" in ${field} does not resolve to a record in the corpus`,
+        adr: record.frontmatter.id,
+        candidateAdr: record.frontmatter.id,
+        relatedAdr: ref,
+        recordPath: record.path,
+        field,
+        lowerLevel: { rule: lowerRule, path: record.path, id: record.frontmatter.id, field },
+      };
+      subs.push({ status: 'fail', reason: danglingReason, finding });
+    }
+  }
+
+  for (const record of ctx.corpusRecords) {
+    check(record, 'supersedes', record.frontmatter.supersedes);
+    check(record, 'relatesTo', record.frontmatter.relatesTo);
+  }
+
+  if (subs.length === 0) return passResult('no-orphan-refs');
+  return aggregate('no-orphan-refs', subs);
+}

package/src/rules/schema-valid.ts

@@ -0,0 +1,49 @@
+/**
+ * @adrkit/evaluator — rule 1: schema-valid (error).
+ *
+ * Reads only the parse/contract findings on `proposalPath` (data-model §3). Any such
+ * finding => fail (error); the orchestrator then emits ten `not-evaluated` results
+ * (C11). Lower-level rule/path/id/field/pattern evidence is preserved in report-only
+ * `RuleFinding` fields; `RuleFinding.adr` stays strictly an AdrRef and never holds a
+ * filesystem path (T017).
+ */
+
+import type { Finding } from '@adrkit/core';
+import { aggregate, passResult, type SubResult } from './kernel.ts';
+import type { ProposalResolution, ReasonCode, RuleFinding, RuleResult } from '../types.ts';
+
+const PARSE_RULES: ReadonlySet<string> = new Set(['frontmatter-parse', 'frontmatter-fence']);
+
+function reasonForFinding(finding: Finding): ReasonCode {
+  if (finding.rule === 'file-read') return 'schema-valid.file-read';
+  if (PARSE_RULES.has(finding.rule)) return 'schema-valid.parse-error';
+  return 'schema-valid.contract-error';
+}
+
+function toRuleFinding(finding: Finding): RuleFinding {
+  return {
+    reason: reasonForFinding(finding),
+    ...(finding.message ? { message: finding.message } : {}),
+    ...(finding.path ? { recordPath: finding.path } : {}),
+    ...(finding.field ? { field: finding.field } : {}),
+    lowerLevel: {
+      rule: finding.rule,
+      ...(finding.path ? { path: finding.path } : {}),
+      ...(finding.id ? { id: finding.id } : {}),
+      ...(finding.field ? { field: finding.field } : {}),
+      ...(finding.pattern ? { pattern: finding.pattern } : {}),
+    },
+  };
+}
+
+export function evaluateSchemaValid(resolution: ProposalResolution): RuleResult {
+  const findings = resolution.schemaFindings;
+  if (findings.length === 0) {
+    return passResult('schema-valid');
+  }
+  const subs: SubResult[] = findings.map((finding) => {
+    const ruleFinding = toRuleFinding(finding);
+    return { status: 'fail', reason: ruleFinding.reason, finding: ruleFinding };
+  });
+  return aggregate('schema-valid', subs);
+}