codex-workflow-v2 2.0.0-beta.13.8 → 2.0.0-beta.14

package/src/lifecycle/semantic-registry.ts

@@ -0,0 +1,572 @@
+import type {
+  CoverageProfileRegistryEntry,
+  CredentialPolicyRegistryEntry,
+  GuardEvaluatorRegistryEntry,
+  IdentityComparatorRegistryEntry,
+  IdentityRegistryEntry,
+  InputRegistryEntry,
+  LimitationRegistryEntry,
+  ProjectionFieldId,
+  ProjectionFieldRef,
+  ProjectionRegistryEntry,
+  RegisteredCoverageProfileRef,
+  RegisteredRef,
+  RegisteredReleaseProfileRef,
+  ReleaseProfileRegistryEntry,
+  SemanticRegistry,
+  SemanticRuleRegistryEntry,
+  VersionedRegistryEntry,
+} from './types.js';
+import { deepFreeze } from './immutable.js';
+import { correctiveReplanBindingManifest } from './corrective-replan-binding-manifest.js';
+
+const v1 = <TId extends string>(id: TId): RegisteredRef<TId> => ({ id, version: 1 });
+
+const correctiveSnapshotRef = v1('projection.corrective-replan.snapshot');
+const correctiveBindingRef = v1('projection.corrective-replan.bindings');
+
+export const exactTransitionCoverageProfileRef: RegisteredCoverageProfileRef =
+  v1('coverage-profile.exact-transition');
+export const exactMutationReleaseProfileRef: RegisteredReleaseProfileRef =
+  v1('release-profile.exact-mutation');
+
+const schemas = [
+  schema('schema.corrective-replan-bindings', 'object', 'Exact corrective transition bindings.'),
+  schema('schema.corrective-replan-snapshot', 'object', 'Current corrective transition snapshot.'),
+  schema('schema.corrective-replan-binding', 'object', 'Exact state-bound receipt binding.'),
+  schema('schema.corrective-replan-plan-validation-attestation', 'object', 'Passed independent Plan Validation attestation.'),
+  schema('schema.corrective-replan-receipt', 'object', 'Human-confirmed execution receipt.'),
+  schema('schema.corrective-replan-task-transaction', 'object', 'Retained corrective-replan Task transaction journal.'),
+  schema('schema.expected-revision', 'integer', 'Expected Task revision.'),
+  schema('schema.plan-risk-audit-input', 'object', 'Replacement Plan Risk Audit input.'),
+  schema('schema.task-id', 'string', 'Task identity.'),
+  schema('schema.task-plan-input', 'object', 'Materialized replacement Task Plan input.'),
+  schema('schema.task-state-readback', 'object', 'Task state readback after Plan replacement.'),
+] as const;
+
+const manifestFields = correctiveReplanBindingManifest.rows.map(({ projection: _projection, ...entry }) => entry.fieldId);
+const manifestProjectionFields = (projectionId: string) => correctiveReplanBindingManifest.rows
+  .filter((entry) => entry.projection.id === projectionId)
+  .map((entry) => entry.fieldId);
+const executionKeyFields = correctiveReplanBindingManifest.rows.map(({ projection, fieldId }) => ({ projection, fieldId }));
+
+const projections: readonly ProjectionRegistryEntry[] = [
+  projection('projection.corrective-replan.bindings', 'schema.corrective-replan-bindings', [
+    'field.candidate-plan-hash',
+    'field.candidate-step-ids',
+    'field.corrective-decision-event-id',
+    'field.current-plan-hash',
+    'field.expected-revision',
+    'field.step-id',
+    'field.task-id',
+  ], 'Current navigation and candidate execution bindings.'),
+  projection('projection.corrective-replan.protocol', 'schema.corrective-replan-binding', manifestProjectionFields('projection.corrective-replan.protocol'), 'Protocol and catalog receipt bindings.'),
+  projection('projection.corrective-replan.state', 'schema.corrective-replan-binding', manifestProjectionFields('projection.corrective-replan.state'), 'Current Task, Knowledge, Git, and corrective posture bindings.'),
+  projection('projection.corrective-replan.candidate', 'schema.corrective-replan-binding', manifestProjectionFields('projection.corrective-replan.candidate'), 'Candidate Plan, Validation, and Risk Audit bindings.'),
+  projection('projection.corrective-replan.authority', 'schema.corrective-replan-binding', manifestProjectionFields('projection.corrective-replan.authority'), 'Actor, Human principal, and capability bindings.'),
+  projection('projection.corrective-replan.execution-receipt', 'schema.corrective-replan-receipt', manifestFields, 'Exact 30-field execution receipt binding.'),
+  projection('projection.corrective-replan.snapshot', 'schema.corrective-replan-snapshot', [
+    'field.candidate-plan-hash',
+    'field.candidate-step-ids',
+    'field.corrective-decision-decision',
+    'field.corrective-decision-event-id',
+    'field.corrective-decision-plan-hash',
+    'field.corrective-decision-step-id',
+    'field.corrective-decision-triggering-attempt-count',
+    'field.corrective-posture',
+    'field.current-plan-hash',
+    'field.in-progress-step-ids',
+    'field.remediation-attempt-count',
+    'field.step-id',
+    'field.step-status',
+    'field.task-id',
+    'field.task-revision',
+    'field.task-status',
+    'field.actor-role-eligible',
+    'field.c1-claim-absent',
+    'field.writer-lease-absent',
+    'field.plan-validation-passed',
+    'field.receipt-valid',
+    'field.risk-audit-passed',
+  ], 'Current mutation-free corrective evaluator snapshot.'),
+  projection('projection.input.expected-revision', 'schema.expected-revision', [
+    'field.expected-revision',
+  ], 'Expected revision input.'),
+  projection('projection.input.plan-risk-audit', 'schema.plan-risk-audit-input', [
+    'field.risk-audit-hash',
+    'field.risk-auditor-identity-hash',
+  ], 'Replacement Plan Risk Audit input.'),
+  projection('projection.input.plan-validation', 'schema.corrective-replan-plan-validation-attestation', [
+    'field.plan-validation-hash', 'field.plan-validator-identity-hash',
+  ], 'Independent candidate-bound Plan Validation input.'),
+  projection('projection.input.execution-receipt', 'schema.corrective-replan-receipt', manifestFields, 'Explicit state-bound corrective-replan receipt.'),
+  projection('projection.input.replacement-plan', 'schema.task-plan-input', [
+    'field.candidate-plan-hash',
+    'field.candidate-step-ids',
+    'field.candidate-step-set-hash',
+  ], 'Prepared replacement Plan input.'),
+  projection('projection.input.task-id', 'schema.task-id', [
+    'field.task-id',
+  ], 'Task identity input.'),
+  projection('projection.task-state.readback', 'schema.task-state-readback', [
+    'field.task-id',
+    'field.task-plan-hash',
+    'field.task-revision',
+    'field.task-status',
+  ], 'Task state post-effect readback projection.'),
+  projection('projection.corrective-replan.terminal-readback', 'schema.task-state-readback', [
+    'field.task-id', 'field.task-revision', 'field.task-status', 'field.current-plan-hash',
+    'field.plan-validation-hash', 'field.risk-audit-hash', 'field.runtime-fingerprint', 'field.catalog-hash',
+  ], 'Domain and retained-terminal-journal readback projection.'),
+];
+
+const inputs: readonly InputRegistryEntry[] = [
+  input('input.corrective-plan-risk-audit', 'operator-input', 'risk-audit-file', 'schema.plan-risk-audit-input', 'projection.input.plan-risk-audit', 'hash-policy.canonical-json-sha256', 'Replacement Plan Risk Audit.'),
+  input('input.corrective-plan-validation', 'operator-input', 'validation-file', 'schema.corrective-replan-plan-validation-attestation', 'projection.input.plan-validation', 'hash-policy.canonical-json-sha256', 'Independent passed Plan Validation.'),
+  input('input.corrective-execution-receipt', 'credential', 'credential-file', 'schema.corrective-replan-receipt', 'projection.input.execution-receipt', 'hash-policy.canonical-json-sha256', 'Human-confirmed exact execution receipt.'),
+  input('input.corrective-replacement-plan', 'operator-input', 'file', 'schema.task-plan-input', 'projection.input.replacement-plan', 'hash-policy.raw-sha256', 'Replacement Plan.'),
+  input('input.expected-revision', 'binding', 'expected-revision', 'schema.expected-revision', 'projection.input.expected-revision', null, 'Expected Task revision.'),
+  input('input.task-id', 'binding', 'id', 'schema.task-id', 'projection.input.task-id', null, 'Task identity.'),
+];
+
+const identities: readonly IdentityRegistryEntry[] = [
+  identity('identity.actor', { kind: 'projection', field: field('projection.corrective-replan.authority', 'field.actor-identity-hash') }, 'Receipt-bound executing actor.'),
+  identity('identity.human-principal', { kind: 'projection', field: field('projection.corrective-replan.authority', 'field.human-principal-identity-hash') }, 'Human confirmation principal.'),
+  identity('identity.plan-author', { kind: 'projection', field: field('projection.corrective-replan.candidate', 'field.plan-author-identity-hash') }, 'Replacement Plan author.'),
+  identity('identity.plan-validator', { kind: 'projection', field: field('projection.corrective-replan.candidate', 'field.plan-validator-identity-hash') }, 'Independent Plan validator.'),
+  identity('identity.risk-auditor', { kind: 'projection', field: field('projection.corrective-replan.candidate', 'field.risk-auditor-identity-hash') }, 'Replacement Plan risk auditor.'),
+  identity('identity.workflow-core', { kind: 'workflow-core' }, 'Workflow Core audit identity.'),
+];
+
+const identityComparators: readonly IdentityComparatorRegistryEntry[] = [
+  comparator('identity-comparator.corrective-replan.author-validator', 'sod.plan-author-plan-validator-distinct', 'identity.plan-author', 'identity.plan-validator', 'distinct'),
+  comparator('identity-comparator.corrective-replan.author-risk-auditor', 'sod.plan-author-risk-auditor-distinct', 'identity.plan-author', 'identity.risk-auditor', 'distinct'),
+  comparator('identity-comparator.corrective-replan.author-human-principal', 'forbidden.plan-author-human-principal-self-authorize', 'identity.plan-author', 'identity.human-principal', 'cannot-authorize'),
+];
+
+const guardEvaluators: readonly GuardEvaluatorRegistryEntry[] = [
+  guardEvaluator('active-decision', [], 'Active corrective decision evaluator.'),
+  guardEvaluator('attempt-threshold', [], 'Corrective remediation threshold evaluator.'),
+  guardEvaluator('bindings-current', ['input.expected-revision', 'input.task-id'], 'Exact binding freshness evaluator.'),
+  guardEvaluator('guarded-step-retained', ['input.corrective-replacement-plan'], 'Candidate guarded Step retention evaluator.'),
+  guardEvaluator('no-step-in-progress', [], 'Running Step exclusion evaluator.'),
+  guardEvaluator('semantic-plan-change', ['input.corrective-replacement-plan'], 'Candidate Plan semantic change evaluator.'),
+  guardEvaluator('source-posture', [], 'Task and guarded Step source posture evaluator.'),
+  guardEvaluator('actor-role-eligible', ['input.corrective-execution-receipt'], 'Exact actor-role eligibility evaluator.'),
+  guardEvaluator('no-c1-claim', ['input.corrective-execution-receipt'], 'C1 claim absence under the Task operation lock.'),
+  guardEvaluator('no-writer-lease', ['input.corrective-execution-receipt'], 'Writer lease absence under the Task operation lock.'),
+  guardEvaluator('plan-validation-passed', ['input.corrective-plan-validation'], 'Exact Plan Validation attestation verifier.'),
+  guardEvaluator('receipt-valid', ['input.corrective-execution-receipt'], 'State-bound execution receipt verifier.'),
+  guardEvaluator('risk-audit-passed', ['input.corrective-plan-risk-audit'], 'Exact candidate-bound Risk Audit verifier.'),
+];
+
+const limitations: readonly LimitationRegistryEntry[] = [
+  limitation('limitation.release-profile.verified-evidence-external', 'accepted', 'Package release evidence is verified outside runtime static readiness.'),
+];
+
+const coverageProfiles: readonly CoverageProfileRegistryEntry[] = [{
+  id: exactTransitionCoverageProfileRef.id,
+  version: exactTransitionCoverageProfileRef.version,
+  description: 'Exact transition positive, hostile, replay, recovery, and postcondition evidence.',
+  requiredEvidenceKinds: [
+    'conditional-effect-false',
+    'conditional-effect-true',
+    'guard-negative',
+    'guard-positive',
+    'journal-phase',
+    'postcondition',
+    'recovery-phase',
+    'replay-conflicting',
+    'replay-identical-completed',
+    'replay-identical-in-progress',
+  ],
+}];
+
+const readinessRuleIds = [
+  'readiness.atomicity.journal-required',
+  'readiness.atomicity.replay-incomplete',
+  'readiness.authority.actor-unbound',
+  'readiness.authority.exact-capability-missing',
+  'readiness.authority.state-bound-receipt-missing',
+  'readiness.catalog.coverage-profile-empty',
+  'readiness.catalog.coverage-report-invalid',
+  'readiness.catalog.coverage-report-missing',
+  'readiness.catalog.empty',
+  'readiness.definition.limitation-blocked',
+  'readiness.effect.narrow-lock-missing',
+  'readiness.effect.race-revalidation-incomplete',
+  'readiness.evidence.coverage-incomplete',
+  'readiness.guard.enforcement-incomplete',
+  'readiness.input.required-not-guarded',
+  'readiness.readback.postcondition-incomplete',
+] as const;
+
+const semanticRules: readonly SemanticRuleRegistryEntry[] = [
+  { id: 'semantic-rule.definition-integrity', version: 1, description: 'Definition limitations and static integrity.', obligationIds: ['obligation.definition-integrity'] },
+  { id: 'semantic-rule.exact-authority', version: 1, description: 'Exact actor, capability, credential, and SoD authority.', obligationIds: ['obligation.exact-authority'] },
+  { id: 'semantic-rule.required-inputs', version: 1, description: 'Required exact mutation inputs and guard coverage.', obligationIds: ['obligation.required-inputs'] },
+  { id: 'semantic-rule.admission-boundary', version: 1, description: 'Exclusive lock and under-lock race revalidation.', obligationIds: ['obligation.admission-boundary'] },
+  { id: 'semantic-rule.reliable-effects', version: 1, description: 'Journal, replay, recovery, and readback completeness.', obligationIds: ['obligation.reliable-effects'] },
+];
+
+const releaseProfiles: readonly ReleaseProfileRegistryEntry[] = [{
+  id: exactMutationReleaseProfileRef.id,
+  version: exactMutationReleaseProfileRef.version,
+  description: 'Fail-closed exact mutating transition release profile.',
+  coverageProfile: exactTransitionCoverageProfileRef,
+  allowedLimitations: [v1('limitation.release-profile.verified-evidence-external')],
+  requiredRules: semanticRules.map(({ id, version }) => ({ id, version })),
+  requireExactAuthority: true,
+  requireExclusiveLockForMutation: true,
+  requireJournalForMultiWrite: true,
+}];
+
+export const transitionSemanticRegistry: SemanticRegistry = deepFreeze(validateSemanticRegistry({
+  inputs,
+  schemas,
+  projections,
+  hashPolicies: [
+    { id: 'hash-policy.canonical-json-sha256', version: 1, description: 'Canonical JSON SHA-256.', algorithm: 'sha256', canonicalization: 'canonical-json' },
+    { id: 'hash-policy.raw-sha256', version: 1, description: 'Raw byte SHA-256.', algorithm: 'sha256', canonicalization: 'raw-bytes' },
+  ],
+  identities,
+  identityComparators,
+  principalBases: [
+    { id: 'principal-basis.human-confirmation', version: 1, description: 'Exact Human confirmation authority basis.', principalKind: 'human', authoritySource: 'human-confirmation' },
+  ],
+  capabilities: [{
+    id: 'capability.task.corrective-replan', version: 1, description: 'Human-issued capability for one exact replacement candidate.',
+    transitionId: 'task.plan.corrective-replan', issuer: v1('identity.human-principal'),
+    scope: v1('projection.corrective-replan.execution-receipt'), exactCandidateBound: true,
+  }],
+  credentialPolicies: [{
+    id: 'credential-policy.corrective-execution-receipt', version: 1, description: 'Exact state-bound Human-confirmed receipt.',
+    credentialKind: 'execution-receipt', schema: v1('schema.corrective-replan-receipt'),
+    verifier: v1('credential-verifier.corrective-replan.receipt'), issuer: v1('identity.human-principal'),
+    presentation: { mode: 'explicit-input', input: v1('input.corrective-execution-receipt') },
+    validity: { mode: 'bounded-ttl', clock: v1('clock.workflow-core-utc'), maxTtlMs: 900_000, skewMs: 30_000, expiryFailureCode: 'CREDENTIAL_EXPIRED' },
+    replay: { mode: 'execution-key-bound', executionKeyPolicy: v1('execution-key-policy.corrective-replan-exact') },
+    binding: { projection: v1('projection.corrective-replan.execution-receipt'), fieldIds: manifestFields },
+  }],
+  credentialVerifiers: [{ id: 'credential-verifier.corrective-replan.receipt', version: 1, description: 'The invoked Core credential kernel recomputes receipt and all current bindings.', verifierKind: 'state-bound-sha256' }],
+  clocks: [{ id: 'clock.workflow-core-utc', version: 1, description: 'Workflow Core injected UTC clock.', clockKind: 'workflow-core-utc' }],
+  delegationPolicies: [
+    { id: 'delegation.forbidden', version: 1, description: 'Delegation is forbidden.', mode: 'forbidden', scopeBound: false, expiryRequired: false, redelegationAllowed: false },
+  ],
+  ownershipPolicies: [
+    { id: 'ownership.corrective-replan-clear', version: 1, description: 'No C1 claim or Writer lease may remain at replan admission.', c1Ownership: 'forbidden', writerLease: 'forbidden', ownerBinding: 'actor' },
+  ],
+  guardEvaluators,
+  effectAdapters: [
+    { id: 'effect-adapter.journaled-corrective-replan', version: 1, description: 'Receipt-bound five-target corrective-replan executor.', adapterKind: 'journaled-corrective-replan' },
+  ],
+  resources: [
+    { id: 'resource.plan-artifact', version: 1, description: 'Published Task Plan artifact.', resourceKind: 'artifact' },
+    { id: 'resource.plan-validation-sidecar', version: 1, description: 'Plan Validation evidence sidecar.', resourceKind: 'sidecar' },
+    { id: 'resource.plan-risk-audit-sidecar', version: 1, description: 'Plan Risk Audit sidecar.', resourceKind: 'sidecar' },
+    { id: 'resource.corrective-replan-execution-sidecar', version: 1, description: 'Corrective-replan execution evidence sidecar.', resourceKind: 'sidecar' },
+    { id: 'resource.corrective-replan-journal', version: 1, description: 'Retained Task corrective-replan journal.', resourceKind: 'journal' },
+    { id: 'resource.task-state', version: 1, description: 'Task state.', resourceKind: 'task-state' },
+  ],
+  lockPolicies: [
+    { id: 'lock-policy.corrective-replan-task-exclusive', version: 1, description: 'Same-slot exclusive Task operation lock.', lockKind: 'exclusive-task', scope: slice('projection.corrective-replan.state', ['field.task-id']) },
+  ],
+  executionKeyPolicies: [
+    { id: 'execution-key-policy.corrective-replan-exact', version: 1, description: 'Exact AD-16 28-field execution key.', requiredFields: executionKeyFields },
+  ],
+  journalSchemas: [{ id: 'journal-schema.corrective-replan-task', version: 1, description: 'Closed retained Task transaction journal.', schema: v1('schema.corrective-replan-task-transaction') }],
+  journalAdapters: [{ id: 'journal-adapter.corrective-replan-task', version: 1, description: 'Durable exact-target Task journal.', compatibleEffectAdapters: [v1('effect-adapter.journaled-corrective-replan')] }],
+  recoveryAdapters: [{ id: 'recovery-adapter.corrective-replan-roll-forward', version: 1, description: 'Explicit apply-or-confirm roll-forward.', compatibleJournalAdapters: [v1('journal-adapter.corrective-replan-task')] }],
+  readbackAdapters: [
+    {
+      id: 'readback-adapter.corrective-replan-terminal',
+      version: 1,
+      description: 'Domain readback before completion and retained-journal readback after terminal.',
+      compatibleEffectAdapters: [v1('effect-adapter.journaled-corrective-replan')],
+      wiring: 'invoked-post-effect',
+      implementationResult: 'projected-readback',
+      validationProjection: v1('projection.corrective-replan.terminal-readback'),
+      projectionWiring: 'invoked',
+    },
+  ],
+  limitations,
+  releaseProfiles,
+  coverageProfiles,
+  coverageProducers: [],
+  semanticRules,
+  readinessRuleIds: [...readinessRuleIds],
+}));
+
+export function validateSemanticRegistry<TRegistry extends SemanticRegistry>(registry: TRegistry): TRegistry {
+  const categories: Array<readonly VersionedRegistryEntry<string>[]> = [
+    registry.inputs,
+    registry.schemas,
+    registry.projections,
+    registry.hashPolicies,
+    registry.identities,
+    registry.identityComparators,
+    registry.principalBases,
+    registry.capabilities,
+    registry.credentialPolicies,
+    registry.credentialVerifiers,
+    registry.clocks,
+    registry.delegationPolicies,
+    registry.ownershipPolicies,
+    registry.guardEvaluators,
+    registry.effectAdapters,
+    registry.resources,
+    registry.lockPolicies,
+    registry.executionKeyPolicies,
+    registry.journalSchemas,
+    registry.journalAdapters,
+    registry.recoveryAdapters,
+    registry.readbackAdapters,
+    registry.limitations,
+    registry.releaseProfiles,
+    registry.coverageProfiles,
+    registry.coverageProducers,
+    registry.semanticRules,
+  ];
+  for (const entries of categories) assertUniqueRegisteredEntries(entries);
+  assertUniqueStrings(registry.readinessRuleIds, 'readiness rule IDs');
+  for (const projectionEntry of registry.projections) {
+    resolveRegistryEntry(registry.schemas, projectionEntry.schema, 'schema');
+    assertUniqueStrings(projectionEntry.fieldIds, `${projectionEntry.id} fields`);
+  }
+  for (const inputEntry of registry.inputs) {
+    resolveRegistryEntry(registry.schemas, inputEntry.schema, 'schema');
+    resolveRegistryEntry(registry.projections, inputEntry.projection, 'projection');
+    if (inputEntry.hashPolicy) resolveRegistryEntry(registry.hashPolicies, inputEntry.hashPolicy, 'hash policy');
+  }
+  for (const identityEntry of registry.identities) {
+    if (identityEntry.normalization) {
+      resolveRegistryEntry(registry.hashPolicies, identityEntry.normalization, 'hash policy');
+    }
+    if (identityEntry.provider.kind === 'projection') assertProjectionField(registry, identityEntry.provider.field);
+  }
+  for (const comparator of registry.identityComparators) {
+    if (comparator.operands.length < 2) throw new TypeError(`Identity comparator ${comparator.id} has fewer than two operands.`);
+    assertUniqueStrings(comparator.operands.map((operand) => `${operand.id}@${operand.version}`), `${comparator.id} operands`);
+    for (const operand of comparator.operands) resolveRegistryEntry(registry.identities, operand, 'identity comparator operand');
+  }
+  for (const capabilityEntry of registry.capabilities) {
+    resolveRegistryEntry(registry.identities, capabilityEntry.issuer, 'identity');
+    resolveRegistryEntry(registry.projections, capabilityEntry.scope, 'projection');
+  }
+  for (const credentialEntry of registry.credentialPolicies) validateCredentialPolicy(registry, credentialEntry);
+  for (const evaluator of registry.guardEvaluators) {
+    resolveRegistryEntry(registry.projections, evaluator.snapshot, 'projection');
+    resolveRegistryEntry(registry.projections, evaluator.binding, 'projection');
+    for (const inputRef of evaluator.allowedInputs) resolveRegistryEntry(registry.inputs, inputRef, 'input');
+  }
+  for (const profile of registry.coverageProfiles) {
+    if (profile.requiredEvidenceKinds.length === 0) throw new TypeError(`Coverage profile ${profile.id} is empty.`);
+    assertUniqueStrings(profile.requiredEvidenceKinds, `${profile.id} evidence kinds`);
+  }
+  for (const profile of registry.releaseProfiles) validateReleaseProfile(registry, profile);
+  for (const policy of registry.executionKeyPolicies) {
+    if (policy.requiredFields.length === 0) throw new TypeError(`Execution key policy ${policy.id} is empty.`);
+    assertUniqueStrings(policy.requiredFields.map(projectionFieldKey), `${policy.id} required fields`);
+    for (const requiredField of policy.requiredFields) assertProjectionField(registry, requiredField);
+  }
+  for (const policy of registry.lockPolicies) {
+    if (policy.lockKind === 'none' && policy.scope !== null) throw new TypeError(`Lock policy ${policy.id} cannot declare a scope.`);
+    if (policy.lockKind !== 'none' && policy.scope === null) throw new TypeError(`Lock policy ${policy.id} requires a scope.`);
+    if (policy.scope) assertProjectionSlice(registry, policy.scope);
+  }
+  for (const adapter of registry.readbackAdapters) {
+    resolveRegistryEntry(registry.projections, adapter.validationProjection, 'readback validation projection');
+    if (adapter.implementationResult === 'raw-task-state' && adapter.projectionWiring !== 'unimplemented') {
+      throw new TypeError(`Readback adapter ${adapter.id} cannot claim projected validation for a raw TaskState result.`);
+    }
+  }
+  return registry;
+}
+
+export function resolveRegistryEntry<TEntry extends VersionedRegistryEntry<string>>(
+  entries: readonly TEntry[],
+  ref: RegisteredRef<string>,
+  label: string,
+): TEntry {
+  const match = entries.find((entry) => entry.id === ref.id && entry.version === ref.version);
+  if (!match) throw new TypeError(`Unknown registered ${label} ${ref.id}@${ref.version}.`);
+  return match;
+}
+
+function validateCredentialPolicy(registry: SemanticRegistry, policy: CredentialPolicyRegistryEntry): void {
+  resolveRegistryEntry(registry.schemas, policy.schema, 'credential schema');
+  resolveRegistryEntry(registry.credentialVerifiers, policy.verifier, 'credential verifier');
+  resolveRegistryEntry(registry.identities, policy.issuer, 'credential issuer');
+  assertProjectionSlice(registry, policy.binding);
+  if (policy.presentation.mode === 'explicit-input') resolveRegistryEntry(registry.inputs, policy.presentation.input, 'credential input');
+  if (policy.validity.mode === 'bounded-ttl') {
+    resolveRegistryEntry(registry.clocks, policy.validity.clock, 'clock');
+    if (!Number.isInteger(policy.validity.maxTtlMs) || policy.validity.maxTtlMs <= 0) {
+      throw new TypeError(`Credential policy ${policy.id} has invalid maxTtlMs.`);
+    }
+    if (!Number.isInteger(policy.validity.skewMs) || policy.validity.skewMs < 0) {
+      throw new TypeError(`Credential policy ${policy.id} has invalid skewMs.`);
+    }
+  }
+  if (policy.replay.mode === 'execution-key-bound') {
+    resolveRegistryEntry(registry.executionKeyPolicies, policy.replay.executionKeyPolicy, 'execution key policy');
+  }
+  if (policy.id === 'credential-policy.corrective-execution-receipt' && policy.version === 1) {
+    const exactProjection = resolveRegistryEntry(
+      registry.projections,
+      v1('projection.corrective-replan.execution-receipt'),
+      'exact corrective receipt projection',
+    );
+    if (policy.binding.projection.id !== exactProjection.id
+      || policy.binding.projection.version !== exactProjection.version
+      || policy.binding.fieldIds.length !== exactProjection.fieldIds.length
+      || exactProjection.fieldIds.some((fieldId) => !policy.binding.fieldIds.includes(fieldId))) {
+      throw new TypeError('Exact corrective receipt policy must bind every registered receipt field exactly once.');
+    }
+    if (policy.presentation.mode !== 'explicit-input'
+      || policy.presentation.input.id !== 'input.corrective-execution-receipt'
+      || policy.validity.mode !== 'bounded-ttl'
+      || policy.replay.mode !== 'execution-key-bound'
+      || policy.verifier.id !== 'credential-verifier.corrective-replan.receipt') {
+      throw new TypeError('Exact corrective receipt policy has incomplete presentation, TTL, replay, or verifier semantics.');
+    }
+  }
+}
+
+function validateReleaseProfile(registry: SemanticRegistry, profile: ReleaseProfileRegistryEntry): void {
+  resolveRegistryEntry(registry.coverageProfiles, profile.coverageProfile, 'coverage profile');
+  assertUniqueStrings(profile.requiredRules.map((rule) => `${rule.id}@${rule.version}`), `${profile.id} semantic rules`);
+  for (const ruleRef of profile.requiredRules) {
+    resolveRegistryEntry(registry.semanticRules, ruleRef, 'semantic rule');
+  }
+  for (const limitationRef of profile.allowedLimitations) {
+    const limitationEntry = resolveRegistryEntry(registry.limitations, limitationRef, 'limitation');
+    if (limitationEntry.disposition !== 'accepted') {
+      throw new TypeError(`Release profile ${profile.id} cannot allow unresolved limitation ${limitationRef.id}@${limitationRef.version}.`);
+    }
+  }
+}
+
+function assertProjectionField(registry: SemanticRegistry, field: { projection: RegisteredRef<string>; fieldId: ProjectionFieldId }): void {
+  const projectionEntry = resolveRegistryEntry(registry.projections, field.projection, 'projection');
+  if (!projectionEntry.fieldIds.includes(field.fieldId)) {
+    throw new TypeError(`Projection ${field.projection.id}@${field.projection.version} has no field ${field.fieldId}.`);
+  }
+}
+
+function assertProjectionSlice(registry: SemanticRegistry, slice: { projection: RegisteredRef<string>; fieldIds: readonly ProjectionFieldId[] }): void {
+  const projectionEntry = resolveRegistryEntry(registry.projections, slice.projection, 'projection');
+  assertUniqueStrings(slice.fieldIds, `${slice.projection.id} slice fields`);
+  for (const fieldId of slice.fieldIds) {
+    if (!projectionEntry.fieldIds.includes(fieldId)) throw new TypeError(`Projection ${slice.projection.id} has no field ${fieldId}.`);
+  }
+}
+
+function assertUniqueRegisteredEntries(entries: readonly VersionedRegistryEntry<string>[]): void {
+  assertUniqueStrings(entries.map((entry) => `${entry.id}@${entry.version}`), 'registered ID/version pairs');
+}
+
+function assertUniqueStrings(values: readonly string[], label: string): void {
+  if (new Set(values).size !== values.length) throw new TypeError(`Duplicate ${label}.`);
+}
+
+function schema(id: SchemaRegistryEntryId, valueKind: 'string' | 'integer' | 'object' | 'array', description: string) {
+  return { id, version: 1, description, valueKind } as const;
+}
+
+type SchemaRegistryEntryId = `schema.${string}`;
+
+function projection(
+  id: `projection.${string}`,
+  schemaId: `schema.${string}`,
+  fieldIds: readonly ProjectionFieldId[],
+  description: string,
+): ProjectionRegistryEntry {
+  return { id, version: 1, description, schema: v1(schemaId), fieldIds };
+}
+
+function input(
+  id: `input.${string}`,
+  source: InputRegistryEntry['source'],
+  cliName: string,
+  schemaId: `schema.${string}`,
+  projectionId: `projection.${string}`,
+  hashPolicyId: `hash-policy.${string}` | null,
+  description: string,
+): InputRegistryEntry {
+  return {
+    id,
+    version: 1,
+    description,
+    source,
+    cliName,
+    schema: v1(schemaId),
+    projection: v1(projectionId),
+    hashPolicy: hashPolicyId ? v1(hashPolicyId) : null,
+  };
+}
+
+function identity(
+  id: `identity.${string}`,
+  provider: IdentityRegistryEntry['provider'],
+  description: string,
+): IdentityRegistryEntry {
+  return { id, version: 1, description, provider, normalization: null };
+}
+
+function comparator(
+  id: `identity-comparator.${string}`,
+  constraintId: `sod.${string}` | `forbidden.${string}`,
+  left: `identity.${string}`,
+  right: `identity.${string}`,
+  relation: IdentityComparatorRegistryEntry['relation'],
+): IdentityComparatorRegistryEntry {
+  return {
+    id, version: 1, description: `Exact ${constraintId} identity comparison.`,
+    transitionId: 'task.plan.corrective-replan', constraintId,
+    operands: [v1(left), v1(right)], relation, missingIdentity: 'block',
+  };
+}
+
+function guardEvaluator(
+  suffix: string,
+  allowedInputIds: readonly `input.${string}`[],
+  description: string,
+): GuardEvaluatorRegistryEntry {
+  return {
+    id: `guard-evaluator.task.corrective-replan.${suffix}`,
+    version: 1,
+    description,
+    transitionId: 'task.plan.corrective-replan',
+    guardId: `task.corrective-replan.${suffix}`,
+    snapshot: correctiveSnapshotRef,
+    binding: correctiveBindingRef,
+    allowedInputs: allowedInputIds.map(v1),
+  };
+}
+
+function limitation(
+  id: `limitation.${string}`,
+  disposition: LimitationRegistryEntry['disposition'],
+  description: string,
+): LimitationRegistryEntry {
+  return { id, version: 1, description, disposition };
+}
+
+function field<TProjection extends `projection.${string}`>(
+  projectionId: TProjection,
+  fieldId: ProjectionFieldId,
+): ProjectionFieldRef {
+  return { projection: v1(projectionId), fieldId };
+}
+
+function slice<TProjection extends `projection.${string}`>(
+  projectionId: TProjection,
+  fieldIds: readonly ProjectionFieldId[],
+) {
+  return { projection: v1(projectionId), fieldIds };
+}
+
+function projectionFieldKey(value: ProjectionFieldRef): string {
+  return `${value.projection.id}@${value.projection.version}:${value.fieldId}`;
+}