codex-workflow-v2 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/src/lifecycle/types.d.ts

@@ -0,0 +1,718 @@
+import type { MilestoneStatus, StepStatus, TaskStatus, WorkflowRole } from '../contracts.js';
+export declare const LIFECYCLE_EPOCH: 2;
+export declare const TRANSITION_DEFINITION_FORMAT_VERSION: 4;
+export declare const TRANSITION_CATALOG_FORMAT_VERSION: 4;
+export type TransitionId = `task.${string}` | `milestone.${string}` | `project.${string}` | `discovery.${string}`;
+export type GuardId = `${string}.${string}`;
+export type EffectId = `effect.${string}`;
+export type PostconditionId = `postcondition.${string}`;
+export type RaceId = `race.${string}`;
+export type RevalidationId = `revalidation.${string}`;
+export type JournalPhaseId = `journal-phase.${string}`;
+export type RecoveryStepId = `recovery-step.${string}`;
+export type LimitationId = `limitation.${string}`;
+export type EvidenceId = `evidence.${string}`;
+export type ReadinessRuleId = `readiness.${string}`;
+export type InputId = `input.${string}`;
+export type SchemaId = `schema.${string}`;
+export type ProjectionId = `projection.${string}`;
+export type ProjectionFieldId = `field.${string}`;
+export type HashPolicyId = `hash-policy.${string}`;
+export type IdentityId = `identity.${string}`;
+export type IdentityComparatorId = `identity-comparator.${string}`;
+export type PrincipalBasisId = `principal-basis.${string}`;
+export type CapabilityId = `capability.${string}`;
+export type CredentialPolicyId = `credential-policy.${string}`;
+export type CredentialVerifierId = `credential-verifier.${string}`;
+export type ClockId = `clock.${string}`;
+export type DelegationPolicyId = `delegation.${string}`;
+export type OwnershipPolicyId = `ownership.${string}`;
+export type GuardEvaluatorId = `guard-evaluator.${string}`;
+export type EffectAdapterId = `effect-adapter.${string}`;
+export type ResourceId = `resource.${string}`;
+export type LockPolicyId = `lock-policy.${string}`;
+export type ExecutionKeyPolicyId = `execution-key-policy.${string}`;
+export type JournalSchemaId = `journal-schema.${string}`;
+export type JournalAdapterId = `journal-adapter.${string}`;
+export type RecoveryAdapterId = `recovery-adapter.${string}`;
+export type ReadbackAdapterId = `readback-adapter.${string}`;
+export type ReleaseProfileId = `release-profile.${string}`;
+export type CoverageProfileId = `coverage-profile.${string}`;
+export type CoverageProducerId = `coverage-producer.${string}`;
+export type SemanticRuleId = `semantic-rule.${string}`;
+export type SemanticObligationId = `obligation.${string}`;
+export interface RegisteredRef<TId extends string> {
+    readonly id: TId;
+    readonly version: number;
+}
+export type RegisteredInputRef = RegisteredRef<InputId>;
+export type RegisteredSchemaRef = RegisteredRef<SchemaId>;
+export type RegisteredProjectionRef = RegisteredRef<ProjectionId>;
+export type RegisteredHashPolicyRef = RegisteredRef<HashPolicyId>;
+export type RegisteredIdentityRef = RegisteredRef<IdentityId>;
+export type RegisteredIdentityComparatorRef = RegisteredRef<IdentityComparatorId>;
+export type RegisteredPrincipalBasisRef = RegisteredRef<PrincipalBasisId>;
+export type RegisteredCapabilityRef = RegisteredRef<CapabilityId>;
+export type RegisteredCredentialPolicyRef = RegisteredRef<CredentialPolicyId>;
+export type RegisteredCredentialVerifierRef = RegisteredRef<CredentialVerifierId>;
+export type RegisteredClockRef = RegisteredRef<ClockId>;
+export type RegisteredDelegationPolicyRef = RegisteredRef<DelegationPolicyId>;
+export type RegisteredOwnershipPolicyRef = RegisteredRef<OwnershipPolicyId>;
+export type RegisteredGuardEvaluatorRef = RegisteredRef<GuardEvaluatorId>;
+export type RegisteredEffectAdapterRef = RegisteredRef<EffectAdapterId>;
+export type RegisteredResourceRef = RegisteredRef<ResourceId>;
+export type RegisteredLockPolicyRef = RegisteredRef<LockPolicyId>;
+export type RegisteredExecutionKeyPolicyRef = RegisteredRef<ExecutionKeyPolicyId>;
+export type RegisteredJournalSchemaRef = RegisteredRef<JournalSchemaId>;
+export type RegisteredJournalAdapterRef = RegisteredRef<JournalAdapterId>;
+export type RegisteredRecoveryAdapterRef = RegisteredRef<RecoveryAdapterId>;
+export type RegisteredReadbackAdapterRef = RegisteredRef<ReadbackAdapterId>;
+export type RegisteredReleaseProfileRef = RegisteredRef<ReleaseProfileId>;
+export type RegisteredCoverageProfileRef = RegisteredRef<CoverageProfileId>;
+export type RegisteredCoverageProducerRef = RegisteredRef<CoverageProducerId>;
+export type RegisteredLimitationRef = RegisteredRef<LimitationId>;
+export type RegisteredSemanticRuleRef = RegisteredRef<SemanticRuleId>;
+export interface ProjectionSliceRef {
+    readonly projection: RegisteredProjectionRef;
+    readonly fieldIds: readonly ProjectionFieldId[];
+}
+export interface ProjectionFieldRef {
+    readonly projection: RegisteredProjectionRef;
+    readonly fieldId: ProjectionFieldId;
+}
+export type LifecycleEntity = 'project' | 'project-memory' | 'discovery' | 'task' | 'milestone' | 'step';
+export type LifecycleScope = 'repository' | 'project' | 'entity' | 'task-step';
+export type NavigationKind = 'executable' | 'choice' | 'human-gate' | 'wait' | 'repair' | 'blocked';
+export type NavigationMode = 'exact' | 'advisory';
+export type TransitionEvaluationPhase = 'availability' | 'execution';
+export type TransitionGuardPhase = TransitionEvaluationPhase;
+export type TransitionGuardStage = 'observation' | 'authority' | 'candidate';
+export type TransitionGuardReasonClass = 'lifecycle-blocker' | 'authority-blocker' | 'candidate-blocker' | 'external-race' | 'integrity-failure';
+export type LifecycleRole = WorkflowRole | 'human-principal' | 'plan-validator' | 'milestone-coordinator' | 'delegate-coordinator' | 'c1-claimant' | 'corrective-auditor' | 'workflow-core' | 'update-migration-operator';
+export type PrincipalKind = 'human' | 'workflow-core' | 'delegation-grant' | 'update-operator';
+export type ExecutionBoundary = 'human' | 'coordinator' | 'worker' | 'reviewer' | 'auditor' | 'workflow-core' | 'update-operator';
+export interface TransitionCommandContract {
+    readonly command: string;
+    readonly noun: string;
+    readonly action: string;
+}
+export interface RegisteredInputRequirement {
+    readonly input: RegisteredInputRef;
+    readonly phase: TransitionEvaluationPhase;
+    readonly required: boolean;
+    readonly sensitivity: 'public' | 'sensitive';
+}
+export interface RegisteredOutputRequirement {
+    readonly outputId: `output.${string}`;
+    readonly channel: 'navigation' | 'result' | 'credential-receipt';
+    readonly sensitivity: 'public' | 'redacted' | 'issuance-only' | 'internal';
+    readonly required: boolean;
+}
+export interface TransitionSourcePosture {
+    readonly taskStatuses: readonly TaskStatus[];
+    readonly milestoneStatuses: readonly MilestoneStatus[];
+    readonly stepStatuses: readonly StepStatus[];
+    readonly correctivePostures: readonly string[];
+}
+export interface TransitionGuardMetadata {
+    readonly guardId: GuardId;
+    readonly semanticVersion: number;
+    readonly phase: TransitionGuardPhase;
+    readonly stage: TransitionGuardStage;
+    readonly reasonClass: TransitionGuardReasonClass;
+    readonly evaluator: RegisteredGuardEvaluatorRef;
+    readonly reads: readonly ProjectionSliceRef[];
+    readonly requiredInputs: readonly RegisteredInputRef[];
+    readonly description: string;
+}
+export interface TransitionActorContract {
+    readonly identity: RegisteredIdentityRef;
+    readonly principalBasis: RegisteredPrincipalBasisRef;
+    readonly required: boolean;
+}
+export interface TransitionPrincipalContract {
+    readonly identity: RegisteredIdentityRef;
+    readonly principalBasis: RegisteredPrincipalBasisRef;
+    readonly issuer: RegisteredIdentityRef;
+    readonly allowedKinds: readonly PrincipalKind[];
+}
+export interface TransitionCapabilityRequirement {
+    readonly capability: RegisteredCapabilityRef;
+    readonly source: 'catalog' | 'principal' | 'credential' | 'state';
+    readonly required: boolean;
+}
+export interface TransitionIdentityGuardEnforcement {
+    readonly kind: 'guard';
+    readonly guardId: GuardId;
+    readonly evaluator: RegisteredGuardEvaluatorRef;
+}
+export interface TransitionIdentityCredentialEnforcement {
+    readonly kind: 'credential-verifier';
+    readonly verifier: RegisteredCredentialVerifierRef;
+}
+export interface TransitionIdentityAttestationEnforcement {
+    readonly kind: 'attestation';
+    readonly input: RegisteredInputRef;
+    readonly verifier: RegisteredCredentialVerifierRef;
+}
+export type TransitionIdentityEnforcement = TransitionIdentityGuardEnforcement | TransitionIdentityCredentialEnforcement | TransitionIdentityAttestationEnforcement;
+export interface TransitionSeparationOfDutyConstraint {
+    readonly constraintId: `sod.${string}`;
+    readonly left: RegisteredIdentityRef;
+    readonly right: RegisteredIdentityRef;
+    readonly relation: 'distinct' | 'same';
+    readonly missingIdentity: 'block' | 'integrity-failure';
+    readonly comparator: RegisteredIdentityComparatorRef;
+    readonly enforcement: TransitionIdentityEnforcement;
+}
+export interface TransitionForbiddenCombination {
+    readonly constraintId: `forbidden.${string}`;
+    readonly subjects: readonly RegisteredIdentityRef[];
+    readonly rule: 'cannot-authorize' | 'cannot-coexist' | 'cannot-delegate' | 'cannot-preserve';
+    readonly missingIdentity: 'block' | 'integrity-failure';
+    readonly comparator: RegisteredIdentityComparatorRef;
+    readonly enforcement: TransitionIdentityEnforcement;
+}
+export interface RegisteredAuthorityContract {
+    readonly eligibleRoles: readonly LifecycleRole[];
+    readonly actor: TransitionActorContract;
+    readonly principal: TransitionPrincipalContract;
+    readonly capabilities: readonly TransitionCapabilityRequirement[];
+    readonly credentials: readonly RegisteredCredentialPolicyRef[];
+    readonly delegation: RegisteredDelegationPolicyRef;
+    readonly ownership: RegisteredOwnershipPolicyRef;
+    readonly executionBoundaries: readonly ExecutionBoundary[];
+    readonly separationOfDuty: readonly TransitionSeparationOfDutyConstraint[];
+    readonly forbiddenCombinations: readonly TransitionForbiddenCombination[];
+}
+export interface TransitionStatusEffect<TStatus extends string> {
+    readonly from: readonly TStatus[];
+    readonly to: TStatus | 'input-dependent' | 'preserved';
+}
+export interface TransitionSupersessionContract {
+    readonly executionAuthorization: 'preserve' | 'supersede-approved' | 'invalidate';
+    readonly finalAcceptance: 'preserve' | 'supersede-approved' | 'invalidate';
+    readonly delegationGrants: 'preserve' | 'supersede' | 'invalidate';
+    readonly c1Claim: 'preserve' | 'supersede' | 'invalidate';
+    readonly writerLease: 'preserve' | 'release' | 'invalidate';
+}
+export type EffectCondition = {
+    readonly kind: 'input-present';
+    readonly input: RegisteredInputRef;
+} | {
+    readonly kind: 'guard-passed';
+    readonly guardId: GuardId;
+};
+export interface TransitionEffectNode {
+    readonly effectId: EffectId;
+    readonly ordinal: number;
+    readonly adapter: RegisteredEffectAdapterRef;
+    readonly resource: RegisteredResourceRef;
+    readonly operation: 'stage' | 'write' | 'append' | 'publish' | 'replace' | 'delete' | 'preserve';
+    readonly conditions: readonly EffectCondition[];
+    readonly dependsOn: readonly EffectId[];
+}
+export interface TransitionPostcondition {
+    readonly postconditionId: PostconditionId;
+    readonly assertion: 'hash-equals' | 'revision-advanced' | 'status-equals' | 'event-appended' | 'path-absent';
+    readonly reads: readonly ProjectionSliceRef[];
+    readonly effectNodeIds: readonly EffectId[];
+}
+export interface OrderedEffectGraph {
+    readonly graphId: `effect-graph.${string}`;
+    readonly graphVersion: number;
+    readonly taskStatus: TransitionStatusEffect<TaskStatus>;
+    readonly milestoneStatus: TransitionStatusEffect<MilestoneStatus>;
+    readonly stepStatus: TransitionStatusEffect<StepStatus>;
+    readonly supersession: TransitionSupersessionContract;
+    readonly orderedNodes: readonly TransitionEffectNode[];
+    readonly postconditions: readonly TransitionPostcondition[];
+}
+export interface TransitionRevalidation {
+    readonly revalidationId: RevalidationId;
+    readonly ordinal: number;
+    readonly raceId: RaceId;
+    readonly guardId: GuardId;
+    readonly evaluator: RegisteredGuardEvaluatorRef;
+    readonly reads: readonly ProjectionSliceRef[];
+    readonly underLock: boolean;
+}
+export interface AdmissionBoundaryContract {
+    readonly lock: {
+        readonly policy: RegisteredLockPolicyRef;
+        readonly scope: ProjectionSliceRef;
+    };
+    readonly orderedRevalidations: readonly TransitionRevalidation[];
+    readonly firstEffectAfterRevalidation: true;
+    readonly release: 'finally-after-readback';
+}
+export interface RegisteredRacePrecondition {
+    readonly raceId: RaceId;
+    readonly reasonClass: 'external-race' | 'integrity-failure';
+    readonly guardId: GuardId;
+    readonly revalidationId: RevalidationId;
+    readonly reads: readonly ProjectionSliceRef[];
+    readonly allowedFailureCodes: readonly ('STATE_CONFLICT' | 'GIT_PRECONDITION_FAILED' | 'CREDENTIAL_EXPIRED' | 'STATE_CORRUPT')[];
+}
+export interface TransitionExecutionKeyContract {
+    readonly policy: RegisteredExecutionKeyPolicyRef;
+    readonly fields: readonly ProjectionFieldRef[];
+    readonly hashPolicy: RegisteredHashPolicyRef;
+}
+export interface TransitionReplayContract {
+    readonly identicalCompleted: 'return-recorded-result' | 'reject';
+    readonly identicalInProgress: 'resume-journal' | 'reject';
+    readonly conflicting: 'reject-state-conflict' | 'reject-transition-blocked';
+}
+export interface TransitionJournalPhase {
+    readonly phaseId: JournalPhaseId;
+    readonly ordinal: number;
+    readonly allowedNextPhaseIds: readonly JournalPhaseId[];
+    readonly terminal: boolean;
+    readonly durable: boolean;
+    readonly effectNodeIds: readonly EffectId[];
+    readonly digestFields: readonly ProjectionFieldRef[];
+}
+export type TransitionJournalContract = {
+    readonly mode: 'none';
+} | {
+    readonly mode: 'required';
+    readonly schema: RegisteredJournalSchemaRef;
+    readonly adapter: RegisteredJournalAdapterRef;
+    readonly digestPolicy: RegisteredHashPolicyRef;
+    readonly orderedPhases: readonly TransitionJournalPhase[];
+};
+export interface TransitionRecoveryStep {
+    readonly stepId: RecoveryStepId;
+    readonly ordinal: number;
+    readonly fromPhaseId: JournalPhaseId;
+    readonly toPhaseId: JournalPhaseId;
+}
+export type TransitionRecoveryContract = {
+    readonly mode: 'manual-integrity-stop';
+    readonly fromPhaseIds: readonly JournalPhaseId[];
+} | {
+    readonly mode: 'automatic-roll-forward' | 'automatic-roll-back';
+    readonly trigger: 'explicit-repair';
+    readonly adapter: RegisteredRecoveryAdapterRef;
+    readonly fromPhaseIds: readonly JournalPhaseId[];
+    readonly orderedSteps: readonly TransitionRecoveryStep[];
+};
+export interface TransitionReadbackContract {
+    readonly adapter: RegisteredReadbackAdapterRef;
+    readonly wiring: 'invoked-post-effect' | 'available-unwired';
+    readonly checkpoints: {
+        readonly preCompletion: 'domain-readback';
+        readonly postTerminal: 'terminal-readback';
+    };
+    readonly projection: RegisteredProjectionRef;
+    readonly postconditionIds: readonly PostconditionId[];
+    readonly resultDigestPolicy: RegisteredHashPolicyRef;
+}
+export interface ExecutionReliabilityContract {
+    readonly classification: 'read-only' | 'single-write' | 'journaled-multi-write' | 'non-transactional-multi-write';
+    readonly nonMutatingFailureGuarantee: 'all-guards-before-effects' | 'best-effort' | 'not-applicable';
+    readonly executionKey: TransitionExecutionKeyContract;
+    readonly replay: TransitionReplayContract;
+    readonly journal: TransitionJournalContract;
+    readonly recovery: TransitionRecoveryContract;
+    readonly readback: TransitionReadbackContract;
+}
+export interface TransitionNavigationMetadata {
+    readonly kind: NavigationKind;
+    readonly mode: NavigationMode;
+    readonly priority: number;
+}
+export interface TransitionEvidenceReference {
+    readonly evidenceId: EvidenceId;
+    readonly sha256: string;
+}
+export interface TransitionReadinessManifest {
+    readonly developmentStage: 'partial' | 'candidate' | 'withdrawn';
+    readonly releaseProfile: RegisteredReleaseProfileRef;
+    readonly coverageProfile: RegisteredCoverageProfileRef;
+    readonly limitations: readonly RegisteredLimitationRef[];
+    readonly evidence: readonly TransitionEvidenceReference[];
+}
+export interface TransitionTraceability {
+    readonly defectIds: readonly string[];
+    readonly invariantIds: readonly string[];
+    readonly positiveEvidence: readonly string[];
+    readonly hostileEvidence: readonly string[];
+}
+export interface TransitionDocumentation {
+    readonly summary: string;
+}
+export interface TransitionDefinitionMetadata {
+    readonly definitionFormatVersion: typeof TRANSITION_DEFINITION_FORMAT_VERSION;
+    readonly transitionId: TransitionId;
+    readonly guardNamespace: GuardId;
+    readonly lifecycleEpoch: typeof LIFECYCLE_EPOCH;
+    readonly entity: LifecycleEntity;
+    readonly scope: LifecycleScope;
+    readonly command: TransitionCommandContract;
+    readonly sourcePosture: TransitionSourcePosture;
+    readonly inputContract: readonly RegisteredInputRequirement[];
+    readonly snapshotContract: RegisteredProjectionRef;
+    readonly bindingContract: RegisteredProjectionRef;
+    readonly outputContract: readonly RegisteredOutputRequirement[];
+    readonly guards: readonly TransitionGuardMetadata[];
+    readonly authority: RegisteredAuthorityContract;
+    readonly effects: OrderedEffectGraph;
+    readonly admissionBoundary: AdmissionBoundaryContract;
+    readonly atomicity: ExecutionReliabilityContract;
+    readonly racePreconditions: readonly RegisteredRacePrecondition[];
+    readonly navigation: TransitionNavigationMetadata;
+    readonly executorAdapter: RegisteredEffectAdapterRef;
+    readonly readinessManifest: TransitionReadinessManifest;
+    readonly traceability: TransitionTraceability;
+    readonly documentation: TransitionDocumentation;
+}
+export interface TransitionGuardResult {
+    readonly guardId: GuardId;
+    readonly status: 'passed' | 'failed' | 'pending';
+    readonly passed: boolean;
+    readonly reasonCode: string;
+    readonly message: string;
+}
+export interface TransitionGuard<TSnapshot, TBindings> {
+    readonly metadata: TransitionGuardMetadata;
+    evaluate(snapshot: Readonly<TSnapshot>, bindings: Readonly<TBindings>): TransitionGuardResult;
+}
+export interface ExecutableTransitionDefinition<TSnapshot, TBindings> {
+    readonly metadata: TransitionDefinitionMetadata;
+    readonly runtimeSemanticFingerprint: string;
+    /** @deprecated Protocol-v1 compatibility alias. Must equal runtimeSemanticFingerprint. */
+    readonly semanticFingerprint: string;
+    readonly definitionManifestHash: string;
+    readonly guards: readonly TransitionGuard<TSnapshot, TBindings>[];
+}
+export interface TransitionEvaluation<TBindings> {
+    readonly transitionId: TransitionId;
+    /** @deprecated Protocol-v1 compatibility alias for runtimeSemanticFingerprint. */
+    readonly semanticFingerprint: string;
+    readonly phase: TransitionEvaluationPhase;
+    readonly allowed: boolean;
+    readonly bindings: Readonly<TBindings>;
+    readonly guardResults: readonly TransitionGuardResult[];
+    readonly blockingGuardIds: readonly GuardId[];
+    readonly pendingGuardIds: readonly GuardId[];
+}
+export interface ExecutableTransitionNavigation<TBindings> {
+    readonly kind: 'executable';
+    readonly transitionId: TransitionId;
+    readonly semanticFingerprint: string;
+    readonly command: string;
+    readonly bindings: Readonly<TBindings>;
+    readonly evaluationPhase: 'availability';
+    readonly pendingInputGuardIds: readonly GuardId[];
+}
+export interface HumanGateTransitionNavigation<TBindings> {
+    readonly kind: 'human-gate';
+    readonly transitionId: TransitionId;
+    readonly semanticFingerprint: string;
+    readonly command: string;
+    readonly bindings: Readonly<TBindings>;
+    readonly evaluationPhase: 'availability';
+    readonly pendingInputGuardIds: readonly GuardId[];
+}
+export interface BlockedTransitionNavigation {
+    readonly kind: 'blocked';
+    readonly transitionId: TransitionId;
+    readonly semanticFingerprint: string;
+    readonly command: string;
+    readonly blockingGuardIds: readonly GuardId[];
+    readonly pendingInputGuardIds: readonly GuardId[];
+    readonly reasonCode: string;
+}
+export interface SerializedTransitionDefinition extends TransitionDefinitionMetadata {
+    readonly runtimeSemanticFingerprint: string;
+    /** @deprecated Protocol-v1 compatibility alias. */
+    readonly semanticFingerprint: string;
+    readonly definitionManifestHash: string;
+}
+export type CoverageEvidenceKind = 'guard-positive' | 'guard-negative' | 'conditional-effect-true' | 'conditional-effect-false' | 'replay-identical-completed' | 'replay-identical-in-progress' | 'replay-conflicting' | 'journal-phase' | 'recovery-phase' | 'postcondition';
+export interface VersionedRegistryEntry<TId extends string> {
+    readonly id: TId;
+    readonly version: number;
+    readonly description: string;
+}
+export interface SchemaRegistryEntry extends VersionedRegistryEntry<SchemaId> {
+    readonly valueKind: 'string' | 'integer' | 'object' | 'array';
+}
+export interface ProjectionRegistryEntry extends VersionedRegistryEntry<ProjectionId> {
+    readonly schema: RegisteredSchemaRef;
+    readonly fieldIds: readonly ProjectionFieldId[];
+}
+export interface InputRegistryEntry extends VersionedRegistryEntry<InputId> {
+    readonly source: 'binding' | 'operator-input' | 'credential';
+    readonly cliName: string;
+    readonly schema: RegisteredSchemaRef;
+    readonly projection: RegisteredProjectionRef;
+    readonly hashPolicy: RegisteredHashPolicyRef | null;
+}
+export interface HashPolicyRegistryEntry extends VersionedRegistryEntry<HashPolicyId> {
+    readonly algorithm: 'sha256';
+    readonly canonicalization: 'raw-bytes' | 'canonical-json' | 'normalized-identity';
+}
+export interface IdentityRegistryEntry extends VersionedRegistryEntry<IdentityId> {
+    readonly provider: {
+        readonly kind: 'projection';
+        readonly field: ProjectionFieldRef;
+    } | {
+        readonly kind: 'workflow-core';
+    } | {
+        readonly kind: 'unbound';
+    };
+    readonly normalization: RegisteredHashPolicyRef | null;
+}
+export interface IdentityComparatorRegistryEntry extends VersionedRegistryEntry<IdentityComparatorId> {
+    readonly transitionId: TransitionId;
+    readonly constraintId: `sod.${string}` | `forbidden.${string}`;
+    readonly operands: readonly RegisteredIdentityRef[];
+    readonly relation: 'distinct' | 'same' | 'cannot-authorize' | 'cannot-coexist' | 'cannot-delegate' | 'cannot-preserve';
+    readonly missingIdentity: 'block' | 'integrity-failure';
+}
+export interface PrincipalBasisRegistryEntry extends VersionedRegistryEntry<PrincipalBasisId> {
+    readonly principalKind: PrincipalKind;
+    readonly authoritySource: 'human-confirmation' | 'workflow-core-derived';
+}
+export interface CapabilityRegistryEntry extends VersionedRegistryEntry<CapabilityId> {
+    readonly transitionId: TransitionId;
+    readonly issuer: RegisteredIdentityRef;
+    readonly scope: RegisteredProjectionRef;
+    readonly exactCandidateBound: boolean;
+}
+export interface CredentialPolicyRegistryEntry extends VersionedRegistryEntry<CredentialPolicyId> {
+    readonly credentialKind: 'transition-binding' | 'execution-receipt';
+    readonly schema: RegisteredSchemaRef;
+    readonly verifier: RegisteredCredentialVerifierRef;
+    readonly issuer: RegisteredIdentityRef;
+    readonly presentation: {
+        readonly mode: 'explicit-input';
+        readonly input: RegisteredInputRef;
+    } | {
+        readonly mode: 'navigation-binding';
+    } | {
+        readonly mode: 'none';
+    };
+    readonly validity: {
+        readonly mode: 'bounded-ttl';
+        readonly clock: RegisteredClockRef;
+        readonly maxTtlMs: number;
+        readonly skewMs: number;
+        readonly expiryFailureCode: 'CREDENTIAL_EXPIRED';
+    } | {
+        readonly mode: 'non-expiring';
+    };
+    readonly replay: {
+        readonly mode: 'execution-key-bound';
+        readonly executionKeyPolicy: RegisteredExecutionKeyPolicyRef;
+    } | {
+        readonly mode: 'single-use';
+    } | {
+        readonly mode: 'unrestricted';
+    };
+    readonly binding: ProjectionSliceRef;
+}
+export interface CredentialVerifierRegistryEntry extends VersionedRegistryEntry<CredentialVerifierId> {
+    readonly verifierKind: 'none' | 'state-bound-sha256';
+}
+export interface ClockRegistryEntry extends VersionedRegistryEntry<ClockId> {
+    readonly clockKind: 'workflow-core-utc';
+}
+export interface DelegationPolicyRegistryEntry extends VersionedRegistryEntry<DelegationPolicyId> {
+    readonly mode: 'forbidden' | 'allowed-exact' | 'required-exact';
+    readonly scopeBound: boolean;
+    readonly expiryRequired: boolean;
+    readonly redelegationAllowed: boolean;
+}
+export interface OwnershipPolicyRegistryEntry extends VersionedRegistryEntry<OwnershipPolicyId> {
+    readonly c1Ownership: 'unchecked' | 'forbidden' | 'required';
+    readonly writerLease: 'unchecked' | 'forbidden' | 'required';
+    readonly ownerBinding: 'none' | 'actor' | 'principal';
+}
+export interface GuardEvaluatorRegistryEntry extends VersionedRegistryEntry<GuardEvaluatorId> {
+    readonly transitionId: TransitionId;
+    readonly guardId: GuardId;
+    readonly snapshot: RegisteredProjectionRef;
+    readonly binding: RegisteredProjectionRef;
+    readonly allowedInputs: readonly RegisteredInputRef[];
+}
+export interface EffectAdapterRegistryEntry extends VersionedRegistryEntry<EffectAdapterId> {
+    readonly adapterKind: 'legacy-set-task-plan' | 'journaled-corrective-replan';
+}
+export interface ResourceRegistryEntry extends VersionedRegistryEntry<ResourceId> {
+    readonly resourceKind: 'artifact-stage' | 'artifact' | 'task-state' | 'sidecar' | 'journal';
+}
+export interface LockPolicyRegistryEntry extends VersionedRegistryEntry<LockPolicyId> {
+    readonly lockKind: 'none' | 'exclusive-task';
+    readonly scope: ProjectionSliceRef | null;
+}
+export interface ExecutionKeyPolicyRegistryEntry extends VersionedRegistryEntry<ExecutionKeyPolicyId> {
+    readonly requiredFields: readonly ProjectionFieldRef[];
+}
+export interface JournalSchemaRegistryEntry extends VersionedRegistryEntry<JournalSchemaId> {
+    readonly schema: RegisteredSchemaRef;
+}
+export interface JournalAdapterRegistryEntry extends VersionedRegistryEntry<JournalAdapterId> {
+    readonly compatibleEffectAdapters: readonly RegisteredEffectAdapterRef[];
+}
+export interface RecoveryAdapterRegistryEntry extends VersionedRegistryEntry<RecoveryAdapterId> {
+    readonly compatibleJournalAdapters: readonly RegisteredJournalAdapterRef[];
+}
+export interface ReadbackAdapterRegistryEntry extends VersionedRegistryEntry<ReadbackAdapterId> {
+    readonly compatibleEffectAdapters: readonly RegisteredEffectAdapterRef[];
+    readonly wiring: 'invoked-post-effect' | 'available-unwired';
+    readonly implementationResult: 'raw-task-state' | 'projected-readback';
+    readonly validationProjection: RegisteredProjectionRef;
+    readonly projectionWiring: 'invoked' | 'unimplemented';
+}
+export interface LimitationRegistryEntry extends VersionedRegistryEntry<LimitationId> {
+    readonly disposition: 'unresolved' | 'accepted';
+}
+export interface ReleaseProfileRegistryEntry extends VersionedRegistryEntry<ReleaseProfileId> {
+    readonly coverageProfile: RegisteredCoverageProfileRef;
+    readonly allowedLimitations: readonly RegisteredLimitationRef[];
+    readonly requiredRules: readonly RegisteredSemanticRuleRef[];
+    readonly requireExactAuthority: boolean;
+    readonly requireExclusiveLockForMutation: boolean;
+    readonly requireJournalForMultiWrite: boolean;
+}
+export interface CoverageProfileRegistryEntry extends VersionedRegistryEntry<CoverageProfileId> {
+    readonly requiredEvidenceKinds: readonly CoverageEvidenceKind[];
+}
+export interface CoverageProducerRegistryEntry extends VersionedRegistryEntry<CoverageProducerId> {
+    readonly producerKind: 'node-test';
+}
+export interface SemanticRuleRegistryEntry extends VersionedRegistryEntry<SemanticRuleId> {
+    readonly obligationIds: readonly SemanticObligationId[];
+}
+export interface SemanticRegistry {
+    readonly inputs: readonly InputRegistryEntry[];
+    readonly schemas: readonly SchemaRegistryEntry[];
+    readonly projections: readonly ProjectionRegistryEntry[];
+    readonly hashPolicies: readonly HashPolicyRegistryEntry[];
+    readonly identities: readonly IdentityRegistryEntry[];
+    readonly identityComparators: readonly IdentityComparatorRegistryEntry[];
+    readonly principalBases: readonly PrincipalBasisRegistryEntry[];
+    readonly capabilities: readonly CapabilityRegistryEntry[];
+    readonly credentialPolicies: readonly CredentialPolicyRegistryEntry[];
+    readonly credentialVerifiers: readonly CredentialVerifierRegistryEntry[];
+    readonly clocks: readonly ClockRegistryEntry[];
+    readonly delegationPolicies: readonly DelegationPolicyRegistryEntry[];
+    readonly ownershipPolicies: readonly OwnershipPolicyRegistryEntry[];
+    readonly guardEvaluators: readonly GuardEvaluatorRegistryEntry[];
+    readonly effectAdapters: readonly EffectAdapterRegistryEntry[];
+    readonly resources: readonly ResourceRegistryEntry[];
+    readonly lockPolicies: readonly LockPolicyRegistryEntry[];
+    readonly executionKeyPolicies: readonly ExecutionKeyPolicyRegistryEntry[];
+    readonly journalSchemas: readonly JournalSchemaRegistryEntry[];
+    readonly journalAdapters: readonly JournalAdapterRegistryEntry[];
+    readonly recoveryAdapters: readonly RecoveryAdapterRegistryEntry[];
+    readonly readbackAdapters: readonly ReadbackAdapterRegistryEntry[];
+    readonly limitations: readonly LimitationRegistryEntry[];
+    readonly releaseProfiles: readonly ReleaseProfileRegistryEntry[];
+    readonly coverageProfiles: readonly CoverageProfileRegistryEntry[];
+    readonly coverageProducers: readonly CoverageProducerRegistryEntry[];
+    readonly semanticRules: readonly SemanticRuleRegistryEntry[];
+    readonly readinessRuleIds: readonly ReadinessRuleId[];
+}
+export interface CompilerDiagnostic {
+    readonly diagnosticId: `compiler.${string}` | `core.${string}`;
+    readonly path: string;
+    readonly ref?: string;
+    readonly message: string;
+}
+export interface ExecutableSemanticBinding extends RegisteredRef<string> {
+    readonly semanticId: `implementation.${string}`;
+    readonly semanticVersion: number;
+    readonly wiring?: 'invoked' | 'available-unwired';
+    readonly implementationResult?: 'raw-task-state' | 'projected-readback';
+    readonly projectionWiring?: 'invoked' | 'unimplemented';
+    readonly evaluate?: (...arguments_: readonly unknown[]) => unknown;
+    readonly execute?: (...arguments_: readonly unknown[]) => unknown;
+    readonly compare?: (...arguments_: readonly unknown[]) => unknown;
+    readonly verify?: (...arguments_: readonly unknown[]) => unknown;
+    readonly hash?: (...arguments_: readonly unknown[]) => unknown;
+    readonly validate?: (...arguments_: readonly unknown[]) => unknown;
+}
+export interface CoreReleaseRuleContext {
+    readonly transition: Readonly<Record<string, unknown>>;
+    readonly registry: Readonly<Record<string, readonly Readonly<Record<string, unknown>>[]>>;
+    readonly policy: Readonly<Record<string, unknown>>;
+}
+export interface CoreReleaseRuleBinding extends RegisteredSemanticRuleRef {
+    readonly implementationId: `implementation.${string}`;
+    readonly implementationVersion: number;
+    readonly callable: (context: CoreReleaseRuleContext) => readonly string[];
+}
+export interface TransitionSchemaArtifact {
+    readonly documentSha256: string;
+    readonly vocabularySha256: string;
+}
+export interface PayloadSchemaArtifactBinding extends RegisteredSchemaRef {
+    readonly implementationId: `implementation.${string}`;
+    readonly implementationVersion: number;
+    readonly documentSha256: string;
+    readonly schemaPointer: string;
+    readonly subschemaSha256: string;
+    readonly document: unknown;
+}
+export interface PayloadSchemaValidatorBinding extends RegisteredSchemaRef {
+    readonly implementationId: `implementation.${string}`;
+    readonly implementationVersion: number;
+    readonly artifactSha256: string;
+    readonly subschemaSha256: string;
+    readonly callable: (raw: unknown) => boolean;
+}
+export interface StaticTransitionReadinessEntry {
+    readonly transitionId: TransitionId;
+    readonly blockers: readonly string[];
+}
+export interface StaticReadinessReport {
+    readonly staticReady: boolean;
+    readonly catalogBlockers: readonly string[];
+    readonly transitions: readonly StaticTransitionReadinessEntry[];
+    readonly reportHash: string;
+}
+export interface CoreCompilerProvenance {
+    readonly compilerId: string;
+    readonly compilerVersion: string;
+    readonly compilerBuildSha256: string;
+    readonly definitionFormatVersion: number;
+    readonly lifecycleEpoch: number;
+    readonly rawCatalogSha256: string;
+    readonly runtimeCatalogHash: string;
+    readonly staticCatalogHash: string;
+    readonly semanticRegistryClosureSha256: string;
+    readonly executableRegistryClosureSha256: string;
+    readonly transitionSchemaArtifactSha256: string;
+    readonly transitionSchemaVocabularySha256: string;
+    readonly transitionSchemaValidatorSha256: string;
+    readonly payloadSchemaClosureSha256: string;
+    readonly officialProfileSha256: string;
+    readonly ruleSetSha256: string;
+    readonly canonicalOrderSha256: string;
+    readonly irSha256: string;
+}
+export interface CoreCompiledTransitionView {
+    readonly transitionId: TransitionId;
+    readonly runtimeSemanticFingerprint: string;
+    readonly definitionManifestHash: string;
+}
+export interface CoreCompiledCatalogHandle {
+    readonly kind: 'core-compiled-transition-catalog';
+    readonly provenance: CoreCompilerProvenance;
+    readonly transitions: readonly CoreCompiledTransitionView[];
+}
+export type CoreCatalogCompileResult = {
+    readonly ok: true;
+    readonly catalog: CoreCompiledCatalogHandle;
+    readonly diagnostics: readonly [];
+    readonly diagnosticsHash: string;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly CompilerDiagnostic[];
+    readonly diagnosticsHash: string;
+};