@etiquekit/etq 1.0.14 → 1.0.16

package/packages/control/src/rubric/loader.ts

@@ -1,326 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { extname } from 'node:path';
-import { parse as parseYaml } from 'yaml';
-import {
-  CHECK_EVALUATIONS,
-  CHECK_SEVERITIES,
-  CONTENT_CLASSES,
-  FIXTURE_KINDS,
-  PROMOTION_EVIDENCE,
-  RUBRIC_OUTCOMES,
-  RUBRIC_STATUSES,
-  RUN_ENVIRONMENTS,
-  type CheckEvaluation,
-  type CheckSeverity,
-  type ConformanceRubric,
-  type ContentClass,
-  type FixtureKind,
-  type PromotionEvidence,
-  type PromotionPolicy,
-  type Rubric,
-  type RubricFixture,
-  type RubricFixtureSet,
-  type RubricOutcome,
-  type RubricStatus,
-  type RunEnvironment,
-  type SandboxRunReceipt,
-  type ValidationCheck,
-  type ValidationRubric,
-} from './types';
-import { assertSharedMemoryScopeId, assertSharedMemoryText, detectMemoryRiskFlags } from '../shared/sanitize';
-
-type JsonRecord = Record<string, unknown>;
-
-function isRecord(value: unknown): value is JsonRecord {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-async function readStructured(path: string): Promise<unknown> {
-  const raw = await readFile(path, 'utf-8');
-  if (extname(path).toLowerCase() === '.json') {
-    return JSON.parse(raw) as unknown;
-  }
-  return parseYaml(raw) as unknown;
-}
-
-function asRecord(value: unknown, name: string): JsonRecord {
-  if (!isRecord(value)) throw new Error(`${name} must be an object`);
-  return value;
-}
-
-function asString(record: JsonRecord, key: string): string {
-  const value = record[key];
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new Error(`${key} must be a non-empty string`);
-  }
-  return value;
-}
-
-function optionalStringArray(record: JsonRecord, key: string): string[] {
-  const value = record[key];
-  if (value === undefined) return [];
-  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
-    throw new Error(`${key} must be a string array`);
-  }
-  return value as string[];
-}
-
-function asStringArray(record: JsonRecord, key: string): string[] {
-  const value = record[key];
-  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
-    throw new Error(`${key} must be a string array`);
-  }
-  return value as string[];
-}
-
-function asEnum<T extends readonly string[]>(values: T, raw: unknown, key: string): T[number] {
-  if (typeof raw !== 'string' || !(values as readonly string[]).includes(raw)) {
-    throw new Error(`${key} must be one of: ${values.join(', ')}`);
-  }
-  return raw as T[number];
-}
-
-function asOptionalEnum<T extends readonly string[]>(values: T, raw: unknown, key: string, fallback: T[number]): T[number] {
-  if (raw === undefined) return fallback;
-  return asEnum(values, raw, key);
-}
-
-function asContentClasses(record: JsonRecord, key: string): ContentClass[] {
-  return asStringArray(record, key).map((item) => asEnum(CONTENT_CLASSES, item, `${key}[]`) as ContentClass);
-}
-
-function assertSafeId(value: string, key: string): void {
-  assertSharedMemoryScopeId(value, key);
-}
-
-function assertSafeText(value: string, key: string): void {
-  assertSharedMemoryText(value, key);
-}
-
-function assertSafeRubricProse(value: string, key: string): void {
-  const flags = detectMemoryRiskFlags(value).filter((flag) => (
-    flag !== 'contains_raw_prompt' && flag !== 'contains_raw_tool_output'
-  ));
-  if (flags.length > 0) {
-    throw new Error(`${key} contains restricted shared-memory content: ${flags.join(', ')}`);
-  }
-}
-
-function assertSemverish(value: string, key: string): void {
-  if (!/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9_.-]+)?$/.test(value)) {
-    throw new Error(`${key} must be semver-like (x.y.z)`);
-  }
-}
-
-function normalizeFixtureRefs(record: JsonRecord, key: string): string[] {
-  const refs = optionalStringArray(record, key);
-  for (const ref of refs) assertSafeText(ref, `${key}[]`);
-  return refs;
-}
-
-function parseValidationChecks(value: unknown): ValidationCheck[] {
-  if (!Array.isArray(value) || value.length === 0) throw new Error('checks must be a non-empty array');
-  return value.map((item, index) => {
-    const record = asRecord(item, `checks[${index}]`);
-    const check: ValidationCheck = {
-      check_id: asString(record, 'check_id'),
-      description: asString(record, 'description'),
-      severity: asEnum(CHECK_SEVERITIES, record.severity, 'severity') as CheckSeverity,
-      evaluation: asEnum(CHECK_EVALUATIONS, record.evaluation, 'evaluation') as CheckEvaluation,
-      evidence_required: asStringArray(record, 'evidence_required'),
-    };
-    assertSafeId(check.check_id, 'check_id');
-    assertSafeRubricProse(check.description, 'description');
-    for (const evidence of check.evidence_required) assertSafeId(evidence, 'evidence_required[]');
-    return check;
-  });
-}
-
-function validateCommonRubric(record: JsonRecord): {
-  rubric_id: string;
-  rubric_version: string;
-  known_bad_fixtures: string[];
-  known_good_fixtures: string[];
-  owner_principal_ref: string;
-  status: RubricStatus;
-} {
-  const rubricId = asString(record, 'rubric_id');
-  const version = asString(record, 'rubric_version');
-  assertSafeId(rubricId, 'rubric_id');
-  assertSemverish(version, 'rubric_version');
-  const owner = asString(record, 'owner_principal_ref');
-  assertSafeText(owner, 'owner_principal_ref');
-  return {
-    rubric_id: rubricId,
-    rubric_version: version,
-    known_bad_fixtures: normalizeFixtureRefs(record, 'known_bad_fixtures'),
-    known_good_fixtures: normalizeFixtureRefs(record, 'known_good_fixtures'),
-    owner_principal_ref: owner,
-    status: asEnum(RUBRIC_STATUSES, record.status, 'status') as RubricStatus,
-  };
-}
-
-export function parseRubric(value: unknown): Rubric {
-  const record = asRecord(value, 'rubric');
-  const common = validateCommonRubric(record);
-  if (typeof record.protocol_surface === 'string') {
-    const failure = asRecord(record.failure_semantics, 'failure_semantics');
-    const rubric: ConformanceRubric = {
-      kind: 'conformance',
-      ...common,
-      protocol_surface: asString(record, 'protocol_surface'),
-      schema_refs: asStringArray(record, 'schema_refs'),
-      forbidden_content_classes: asContentClasses(record, 'forbidden_content_classes'),
-      citation_rules: optionalStringArray(record, 'citation_rules'),
-      sanitizer_expectations: optionalStringArray(record, 'sanitizer_expectations'),
-      failure_semantics: {
-        on_reject: asEnum(['block', 'warn'] as const, failure.on_reject, 'failure_semantics.on_reject'),
-        on_uncertain: asEnum(['warn', 'require_review'] as const, failure.on_uncertain, 'failure_semantics.on_uncertain'),
-      },
-    };
-    assertSafeId(rubric.protocol_surface, 'protocol_surface');
-    if (rubric.schema_refs.length === 0) throw new Error('schema_refs must not be empty');
-    for (const ref of rubric.schema_refs) assertSafeText(ref, 'schema_refs[]');
-    for (const rule of rubric.citation_rules) assertSafeRubricProse(rule, 'citation_rules[]');
-    for (const expectation of rubric.sanitizer_expectations) assertSafeRubricProse(expectation, 'sanitizer_expectations[]');
-    return rubric;
-  }
-
-  const rubric: ValidationRubric = {
-    kind: 'validation',
-    ...common,
-    domain: asString(record, 'domain'),
-    artifact_type: asString(record, 'artifact_type'),
-    title: asString(record, 'title'),
-    summary: asString(record, 'summary'),
-    checks: parseValidationChecks(record.checks),
-    evidence_requirements: asStringArray(record, 'evidence_requirements'),
-  };
-  assertSafeId(rubric.domain, 'domain');
-  assertSafeId(rubric.artifact_type, 'artifact_type');
-  assertSafeRubricProse(rubric.title, 'title');
-  assertSafeRubricProse(rubric.summary, 'summary');
-  for (const evidence of rubric.evidence_requirements) assertSafeId(evidence, 'evidence_requirements[]');
-  return rubric;
-}
-
-export async function loadRubric(path: string): Promise<Rubric> {
-  return parseRubric(await readStructured(path));
-}
-
-function fixturePayload(record: JsonRecord): unknown {
-  if (record.input !== undefined) return record.input;
-  if (record.input_text !== undefined) return record.input_text;
-  if (record.artifact !== undefined) return record.artifact;
-  if (record.payload !== undefined) return record.payload;
-  if (record.metadata !== undefined) return record.metadata;
-  if (record.sample !== undefined) return record.sample;
-  return undefined;
-}
-
-function parseFixture(value: unknown, index: number): RubricFixture {
-  const record = asRecord(value, `fixtures[${index}]`);
-  const fixture: RubricFixture = {
-    fixture_id: asString(record, 'fixture_id'),
-    fixture_version: asString(record, 'fixture_version'),
-    content_class: asEnum(CONTENT_CLASSES, record.content_class, 'content_class') as ContentClass,
-    fixture_kind: asEnum(FIXTURE_KINDS, record.fixture_kind, 'fixture_kind') as FixtureKind,
-    artifact_type: asString(record, 'artifact_type'),
-    input_ref: asString(record, 'input_ref'),
-    expected: asEnum(RUBRIC_OUTCOMES, record.expected, 'expected') as RubricOutcome,
-    rationale: asString(record, 'rationale'),
-    input: fixturePayload(record),
-  };
-  assertSafeId(fixture.fixture_id, 'fixture_id');
-  assertSemverish(fixture.fixture_version, 'fixture_version');
-  assertSafeId(fixture.artifact_type, 'artifact_type');
-  assertSafeText(fixture.input_ref, 'input_ref');
-  assertSafeRubricProse(fixture.rationale, 'rationale');
-  return fixture;
-}
-
-export function parseFixtureSet(value: unknown): RubricFixtureSet {
-  const record = asRecord(value, 'fixture_set');
-  const fixturesRaw = record.fixtures;
-  if (!Array.isArray(fixturesRaw) || fixturesRaw.length === 0) {
-    throw new Error('fixtures must be a non-empty array');
-  }
-  const fixtureSet: RubricFixtureSet = {
-    fixture_set_id: asString(record, 'fixture_set_id'),
-    fixture_set_version: typeof record.fixture_set_version === 'string' ? record.fixture_set_version : '0.1.0',
-    fixtures: fixturesRaw.map(parseFixture),
-  };
-  assertSafeText(fixtureSet.fixture_set_id, 'fixture_set_id');
-  assertSemverish(fixtureSet.fixture_set_version, 'fixture_set_version');
-  return fixtureSet;
-}
-
-export async function loadFixtureSet(path: string): Promise<RubricFixtureSet> {
-  return parseFixtureSet(await readStructured(path));
-}
-
-export function validateSandboxReceipt(receipt: SandboxRunReceipt): void {
-  if (receipt.schema !== 'sandbox-run-receipt.v0') throw new Error('receipt schema must be sandbox-run-receipt.v0');
-  assertSafeText(receipt.receipt_id, 'receipt_id');
-  assertSafeId(receipt.rubric_id, 'rubric_id');
-  assertSemverish(receipt.rubric_version, 'rubric_version');
-  assertSafeText(receipt.fixture_set_ref, 'fixture_set_ref');
-  if (!Number.isFinite(Date.parse(receipt.run_at))) throw new Error('run_at must be an ISO-8601 timestamp');
-  assertSafeText(receipt.run_by, 'run_by');
-  asEnum(RUN_ENVIRONMENTS, receipt.run_environment, 'run_environment');
-  if (!Array.isArray(receipt.results)) throw new Error('results must be an array');
-  for (const [index, result] of receipt.results.entries()) {
-    assertSafeId(result.fixture_id, `results[${index}].fixture_id`);
-    asEnum(RUBRIC_OUTCOMES, result.expected, `results[${index}].expected`);
-    asEnum(RUBRIC_OUTCOMES, result.actual, `results[${index}].actual`);
-    assertSafeText(result.reason, `results[${index}].reason`);
-  }
-  const unsafe = detectMemoryRiskFlags(JSON.stringify(receipt));
-  if (unsafe.length > 0) {
-    throw new Error(`sandbox receipt contains restricted shared content: ${unsafe.join(', ')}`);
-  }
-}
-
-export function parseSandboxReceipt(value: unknown): SandboxRunReceipt {
-  const record = asRecord(value, 'sandbox_run_receipt') as unknown as SandboxRunReceipt;
-  validateSandboxReceipt(record);
-  return record;
-}
-
-export async function loadSandboxReceipt(path: string): Promise<SandboxRunReceipt> {
-  return parseSandboxReceipt(await readStructured(path));
-}
-
-export function parsePromotionPolicy(value: unknown): PromotionPolicy {
-  const record = asRecord(value, 'promotion_policy');
-  const applies = asRecord(record.applies_to, 'applies_to');
-  const policy: PromotionPolicy = {
-    policy_id: asString(record, 'policy_id'),
-    policy_version: asString(record, 'policy_version'),
-    applies_to: {
-      domains: optionalStringArray(applies, 'domains'),
-      artifact_types: optionalStringArray(applies, 'artifact_types'),
-      protocol_surfaces: optionalStringArray(applies, 'protocol_surfaces'),
-    },
-    proposer_actor: asString(record, 'proposer_actor'),
-    reviewer_set: asStringArray(record, 'reviewer_set'),
-    required_evidence: asStringArray(record, 'required_evidence')
-      .map((item) => asEnum(PROMOTION_EVIDENCE, item, 'required_evidence[]') as PromotionEvidence),
-    grant_ref: record.grant_ref === null || record.grant_ref === undefined ? null : asString(record, 'grant_ref'),
-    activation_status: asEnum(
-      ['proposed', 'ready_for_grant', 'active', 'rejected', 'retired'] as const,
-      record.activation_status,
-      'activation_status',
-    ),
-  };
-  assertSafeId(policy.policy_id, 'policy_id');
-  assertSemverish(policy.policy_version, 'policy_version');
-  assertSafeText(policy.proposer_actor, 'proposer_actor');
-  for (const reviewer of policy.reviewer_set) assertSafeText(reviewer, 'reviewer_set[]');
-  if (policy.grant_ref) assertSafeText(policy.grant_ref, 'grant_ref');
-  return policy;
-}
-
-export async function loadPromotionPolicy(path: string): Promise<PromotionPolicy> {
-  return parsePromotionPolicy(await readStructured(path));
-}

package/packages/control/src/rubric/promotion.ts

@@ -1,54 +0,0 @@
-import {
-  PROMOTION_EVIDENCE,
-  type PromotionEvidence,
-  type PromotionPolicy,
-  type PromotionReadiness,
-  type Rubric,
-  type SandboxRunReceipt,
-} from './types';
-
-export function evaluatePromotionReadiness(options: {
-  rubric: Rubric;
-  receipt: SandboxRunReceipt;
-  policy?: PromotionPolicy;
-  grantRef?: string;
-}): PromotionReadiness {
-  const evidence: Record<PromotionEvidence, boolean> = {
-    schema_valid_rubric: true,
-    schema_valid_fixture_set: options.receipt.fixture_set_ref.startsWith('fixture-set:'),
-    sandbox_run_receipt: options.receipt.summary.unexpected_outcomes === 0,
-    known_bad_rejection: options.receipt.summary.known_bad_rejected > 0,
-    known_good_acceptance: options.receipt.summary.known_good_accepted > 0,
-  };
-  if (options.receipt.rubric_id !== options.rubric.rubric_id) {
-    evidence.sandbox_run_receipt = false;
-  }
-  if (options.receipt.rubric_version !== options.rubric.rubric_version) {
-    evidence.sandbox_run_receipt = false;
-  }
-
-  const required = options.policy?.required_evidence ?? [...PROMOTION_EVIDENCE];
-  const missing: string[] = required.filter((key) => !evidence[key]);
-  const grantRef = options.grantRef ?? options.policy?.grant_ref ?? null;
-  if (!grantRef) missing.push('grant_ref');
-
-  const evidenceComplete = required.every((key) => evidence[key]);
-  const recommendation = !evidenceComplete
-    ? 'blocked'
-    : grantRef
-      ? 'ready_to_activate'
-      : 'ready_for_grant';
-
-  return {
-    rubric_id: options.rubric.rubric_id,
-    rubric_version: options.rubric.rubric_version,
-    evidence,
-    missing,
-    grant_ref: grantRef,
-    recommendation,
-    authority_boundary: {
-      can_activate_rubric: false,
-      requires_operator_principal_grant: true,
-    },
-  };
-}

package/packages/control/src/rubric/runner.ts

@@ -1,159 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { stringify as stringifyYaml } from 'yaml';
-import { detectMemoryRiskFlags } from '../shared/sanitize';
-import {
-  CONTENT_CLASSES,
-  RUN_ENVIRONMENTS,
-  type ContentClass,
-  type Rubric,
-  type RubricFixture,
-  type RubricFixtureSet,
-  type RubricOutcome,
-  type RunEnvironment,
-  type SandboxRunReceipt,
-} from './types';
-import { validateSandboxReceipt } from './loader';
-
-function sha(input: string): string {
-  return createHash('sha256').update(input).digest('hex').slice(0, 12);
-}
-
-function stringifyInput(value: unknown, fallback: string): string {
-  if (value === undefined) return fallback;
-  if (typeof value === 'string') return value;
-  return JSON.stringify(value);
-}
-
-function flagsToContentClasses(value: string): ContentClass[] {
-  const classes = new Set<ContentClass>();
-  for (const flag of detectMemoryRiskFlags(value)) {
-    if (flag === 'contains_local_path') classes.add('local_path');
-    if (flag === 'contains_hostname') classes.add('hostname');
-    if (flag === 'contains_credential') classes.add('credential');
-    if (flag === 'contains_raw_prompt') classes.add('raw_prompt');
-    if (flag === 'contains_raw_tool_output') classes.add('raw_tool_output');
-    if (flag === 'contains_source_snippet') classes.add('source_snippet');
-  }
-  if (/\b(?:uncited|citation missing|no evidence_ref|without citation)\b/i.test(value)) {
-    classes.add('uncited_claim');
-  }
-  if (/\b(?:unsupported_schema_field|unknown field|extra field|not in schema)\b/i.test(value)) {
-    classes.add('unsupported_schema_field');
-  }
-  return [...classes];
-}
-
-function declaredContentClasses(rubric: Rubric, fixtures: RubricFixture[]): ContentClass[] {
-  if (rubric.kind === 'conformance') return rubric.forbidden_content_classes;
-  const fromKnownBad = fixtures
-    .filter((fixture) => fixture.fixture_kind === 'known_bad')
-    .map((fixture) => fixture.content_class);
-  return [...new Set(fromKnownBad)];
-}
-
-function validateFixtureCoverage(classes: ContentClass[], fixtureSet: RubricFixtureSet): void {
-  if (classes.length === 0) throw new Error('rubric sandbox needs at least one declared content class');
-  const good = fixtureSet.fixtures.filter((fixture) => fixture.fixture_kind === 'known_good');
-  if (good.length < 1) {
-    throw new Error('fixture coverage requires at least one known_good fixture');
-  }
-  for (const contentClass of classes) {
-    const badCount = fixtureSet.fixtures.filter(
-      (fixture) => fixture.fixture_kind === 'known_bad' && fixture.content_class === contentClass,
-    ).length;
-    if (badCount < 2) {
-      throw new Error(`fixture coverage requires at least 2 known_bad fixtures for ${contentClass}`);
-    }
-  }
-}
-
-function validationSignal(value: unknown): RubricOutcome | undefined {
-  if (typeof value === 'string') {
-    const match = value.match(/\bvalidation_signal:(pass|warn|reject)\b/i);
-    return match ? match[1].toLowerCase() as RubricOutcome : undefined;
-  }
-  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-    const signal = (value as Record<string, unknown>).validation_signal;
-    if (signal === 'pass' || signal === 'warn' || signal === 'reject') return signal;
-  }
-  return undefined;
-}
-
-function evaluateFixture(rubric: Rubric, fixture: RubricFixture): { actual: RubricOutcome; reason: string } {
-  const content = stringifyInput(fixture.input, fixture.input_ref);
-  if (rubric.kind === 'validation') {
-    const signal = validationSignal(fixture.input);
-    if (signal) return { actual: signal, reason: `validation fixture declared ${signal}` };
-  }
-
-  const detected = flagsToContentClasses(content);
-  const forbidden = rubric.kind === 'conformance'
-    ? rubric.forbidden_content_classes
-    : CONTENT_CLASSES.filter((contentClass) => contentClass === fixture.content_class);
-  const matched = detected.filter((contentClass) => forbidden.includes(contentClass));
-  if (matched.length > 0) {
-    return {
-      actual: 'reject',
-      reason: `detected forbidden content class: ${matched.sort().join(', ')}`,
-    };
-  }
-  return {
-    actual: 'pass',
-    reason: 'no forbidden content classes detected',
-  };
-}
-
-export async function runRubricSandbox(options: {
-  rubric: Rubric;
-  fixtureSet: RubricFixtureSet;
-  runBy: string;
-  runEnvironment?: RunEnvironment;
-  runAt?: string;
-  receiptPath?: string;
-}): Promise<SandboxRunReceipt> {
-  const runEnvironment = options.runEnvironment ?? 'local';
-  if (!RUN_ENVIRONMENTS.includes(runEnvironment)) {
-    throw new Error(`run_environment must be one of: ${RUN_ENVIRONMENTS.join(', ')}`);
-  }
-  const classes = declaredContentClasses(options.rubric, options.fixtureSet.fixtures);
-  validateFixtureCoverage(classes, options.fixtureSet);
-  const runAt = options.runAt ? new Date(options.runAt).toISOString() : new Date().toISOString();
-  const results = options.fixtureSet.fixtures.map((fixture) => {
-    const evaluated = evaluateFixture(options.rubric, fixture);
-    return {
-      fixture_id: fixture.fixture_id,
-      expected: fixture.expected,
-      actual: evaluated.actual,
-      reason: evaluated.reason,
-    };
-  });
-  const receipt: SandboxRunReceipt = {
-    schema: 'sandbox-run-receipt.v0',
-    receipt_id: `sandbox-run:${options.rubric.rubric_id}:${sha(`${options.fixtureSet.fixture_set_id}:${runAt}`)}`,
-    rubric_id: options.rubric.rubric_id,
-    rubric_version: options.rubric.rubric_version,
-    fixture_set_ref: `fixture-set:${options.fixtureSet.fixture_set_id}`,
-    results,
-    summary: {
-      total_fixtures: results.length,
-      known_bad_rejected: options.fixtureSet.fixtures
-        .filter((fixture, index) => fixture.fixture_kind === 'known_bad' && results[index]?.actual === 'reject')
-        .length,
-      known_good_accepted: options.fixtureSet.fixtures
-        .filter((fixture, index) => fixture.fixture_kind === 'known_good' && results[index]?.actual === 'pass')
-        .length,
-      unexpected_outcomes: results.filter((result) => result.actual !== result.expected).length,
-    },
-    run_at: runAt,
-    run_by: options.runBy,
-    run_environment: runEnvironment,
-  };
-  validateSandboxReceipt(receipt);
-  if (options.receiptPath) {
-    await mkdir(dirname(options.receiptPath), { recursive: true });
-    await writeFile(options.receiptPath, stringifyYaml(receipt));
-  }
-  return receipt;
-}

package/packages/control/src/rubric/types.ts

@@ -1,158 +0,0 @@
-export const RUBRIC_STATUSES = ['rubric_candidate', 'active_rubric', 'retired'] as const;
-export type RubricStatus = typeof RUBRIC_STATUSES[number];
-
-export const CHECK_SEVERITIES = ['block', 'warn', 'info'] as const;
-export type CheckSeverity = typeof CHECK_SEVERITIES[number];
-
-export const CHECK_EVALUATIONS = ['deterministic', 'reviewer_judgment', 'external_tool'] as const;
-export type CheckEvaluation = typeof CHECK_EVALUATIONS[number];
-
-export const CONTENT_CLASSES = [
-  'local_path',
-  'hostname',
-  'credential',
-  'raw_prompt',
-  'raw_tool_output',
-  'source_snippet',
-  'uncited_claim',
-  'unsupported_schema_field',
-] as const;
-export type ContentClass = typeof CONTENT_CLASSES[number];
-
-export const FIXTURE_KINDS = ['known_bad', 'known_good'] as const;
-export type FixtureKind = typeof FIXTURE_KINDS[number];
-
-export const RUBRIC_OUTCOMES = ['pass', 'warn', 'reject'] as const;
-export type RubricOutcome = typeof RUBRIC_OUTCOMES[number];
-
-export const RUN_ENVIRONMENTS = ['local', 'sandbox-isolated'] as const;
-export type RunEnvironment = typeof RUN_ENVIRONMENTS[number];
-
-export const PROMOTION_EVIDENCE = [
-  'schema_valid_rubric',
-  'schema_valid_fixture_set',
-  'sandbox_run_receipt',
-  'known_bad_rejection',
-  'known_good_acceptance',
-] as const;
-export type PromotionEvidence = typeof PROMOTION_EVIDENCE[number];
-
-export interface ValidationCheck {
-  check_id: string;
-  description: string;
-  severity: CheckSeverity;
-  evaluation: CheckEvaluation;
-  evidence_required: string[];
-}
-
-export interface ValidationRubric {
-  kind: 'validation';
-  rubric_id: string;
-  rubric_version: string;
-  domain: string;
-  artifact_type: string;
-  title: string;
-  summary: string;
-  checks: ValidationCheck[];
-  known_bad_fixtures: string[];
-  known_good_fixtures: string[];
-  evidence_requirements: string[];
-  owner_principal_ref: string;
-  status: RubricStatus;
-}
-
-export interface ConformanceRubric {
-  kind: 'conformance';
-  rubric_id: string;
-  rubric_version: string;
-  protocol_surface: string;
-  schema_refs: string[];
-  forbidden_content_classes: ContentClass[];
-  citation_rules: string[];
-  sanitizer_expectations: string[];
-  failure_semantics: {
-    on_reject: 'block' | 'warn';
-    on_uncertain: 'warn' | 'require_review';
-  };
-  known_bad_fixtures: string[];
-  known_good_fixtures: string[];
-  owner_principal_ref: string;
-  status: RubricStatus;
-}
-
-export type Rubric = ValidationRubric | ConformanceRubric;
-
-export interface RubricFixture {
-  fixture_id: string;
-  fixture_version: string;
-  content_class: ContentClass;
-  fixture_kind: FixtureKind;
-  artifact_type: string;
-  input_ref: string;
-  expected: RubricOutcome;
-  rationale: string;
-  input?: unknown;
-}
-
-export interface RubricFixtureSet {
-  fixture_set_id: string;
-  fixture_set_version: string;
-  fixtures: RubricFixture[];
-}
-
-export interface SandboxResult {
-  fixture_id: string;
-  expected: RubricOutcome;
-  actual: RubricOutcome;
-  reason: string;
-}
-
-export interface SandboxRunReceipt {
-  schema: 'sandbox-run-receipt.v0';
-  receipt_id: string;
-  rubric_id: string;
-  rubric_version: string;
-  fixture_set_ref: string;
-  results: SandboxResult[];
-  summary: {
-    total_fixtures: number;
-    known_bad_rejected: number;
-    known_good_accepted: number;
-    unexpected_outcomes: number;
-  };
-  run_at: string;
-  run_by: string;
-  run_environment: RunEnvironment;
-}
-
-export interface PromotionPolicy {
-  policy_id: string;
-  policy_version: string;
-  applies_to: {
-    domains: string[];
-    artifact_types: string[];
-    protocol_surfaces: string[];
-  };
-  proposer_actor: string;
-  reviewer_set: string[];
-  required_evidence: PromotionEvidence[];
-  grant_ref: string | null;
-  activation_status: 'proposed' | 'ready_for_grant' | 'active' | 'rejected' | 'retired';
-  rollback_path?: {
-    retire_command: string;
-    replacement_policy_ref: string | null;
-  };
-}
-
-export interface PromotionReadiness {
-  rubric_id: string;
-  rubric_version: string;
-  evidence: Record<PromotionEvidence, boolean>;
-  missing: string[];
-  grant_ref: string | null;
-  recommendation: 'blocked' | 'ready_for_grant' | 'ready_to_activate';
-  authority_boundary: {
-    can_activate_rubric: false;
-    requires_operator_principal_grant: true;
-  };
-}