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

package/src/lifecycle/evaluator.ts

@@ -0,0 +1,48 @@
+import type {
+  ExecutableTransitionDefinition,
+  TransitionEvaluation,
+  TransitionEvaluationPhase,
+  TransitionGuardResult,
+} from './types.js';
+
+export function evaluateTransition<TSnapshot, TBindings>(
+  definition: ExecutableTransitionDefinition<TSnapshot, TBindings>,
+  snapshot: Readonly<TSnapshot>,
+  bindings: Readonly<TBindings>,
+  phase: TransitionEvaluationPhase,
+): TransitionEvaluation<TBindings> {
+  const guardResults: TransitionGuardResult[] = definition.guards.map((guard) => {
+    if (guard.metadata.phase === 'execution' && phase === 'availability') {
+      return {
+        guardId: guard.metadata.guardId,
+        status: 'pending',
+        passed: false,
+        reasonCode: 'PENDING_OPERATOR_INPUT',
+        message: 'Guard requires operator input and will be evaluated before effects.',
+      };
+    }
+    const result = guard.evaluate(snapshot, bindings);
+    if (result.guardId !== guard.metadata.guardId) {
+      throw new TypeError(
+        `Guard ${guard.metadata.guardId} returned result for ${result.guardId}.`,
+      );
+    }
+    return result;
+  });
+  const blockingGuardIds = guardResults
+    .filter((result) => result.status === 'failed')
+    .map((result) => result.guardId);
+  const pendingGuardIds = guardResults
+    .filter((result) => result.status === 'pending')
+    .map((result) => result.guardId);
+  return {
+    transitionId: definition.metadata.transitionId,
+    semanticFingerprint: definition.semanticFingerprint,
+    phase,
+    allowed: blockingGuardIds.length === 0,
+    bindings,
+    guardResults,
+    blockingGuardIds,
+    pendingGuardIds,
+  };
+}

package/src/lifecycle/fingerprint.ts

@@ -0,0 +1,488 @@
+import { transitionSemanticRegistry } from './semantic-registry.js';
+import { hashCanonical } from './canonical-hash.js';
+export { hashCanonical } from './canonical-hash.js';
+export type { CanonicalJsonValue } from './canonical-hash.js';
+import { coreReleaseRuleDescriptors, correctiveReplanExecutableSemanticIdentity } from './implementation-table.js';
+import {
+  LIFECYCLE_EPOCH,
+  TRANSITION_CATALOG_FORMAT_VERSION,
+  type EffectCondition,
+  type ProjectionFieldRef,
+  type ProjectionSliceRef,
+  type RegisteredRef,
+  type RegisteredRacePrecondition,
+  type SemanticRegistry,
+  type SerializedTransitionDefinition,
+  type TransitionDefinitionMetadata,
+  type TransitionEffectNode,
+  type TransitionGuardMetadata,
+  type TransitionId,
+  type TransitionJournalPhase,
+  type TransitionPostcondition,
+  type TransitionRevalidation,
+  type VersionedRegistryEntry,
+} from './types.js';
+
+type RuntimeRegistryCategory = Exclude<keyof SemanticRegistry,
+  'coverageProducers' | 'coverageProfiles' | 'limitations' | 'readinessRuleIds' | 'releaseProfiles' | 'semanticRules'>;
+type ReadinessRegistryCategory = 'coverageProducers' | 'coverageProfiles' | 'limitations' | 'releaseProfiles' | 'semanticRules';
+
+export interface RuntimeSemanticProjection {
+  readonly semantics: unknown;
+  readonly resolvedRegistryEntries: readonly unknown[];
+  readonly executableSemantics: unknown;
+}
+
+export interface DefinitionManifestProjection {
+  readonly runtimeSemanticFingerprint: string;
+  readonly readinessManifest: unknown;
+  readonly traceability: unknown;
+  readonly resolvedReadinessRegistryEntries: readonly unknown[];
+}
+
+export function runtimeSemanticProjection(
+  metadata: TransitionDefinitionMetadata,
+): RuntimeSemanticProjection {
+  if (arguments.length !== 1) throw new TypeError('Custom semantic registries are not accepted by installed identity helpers.');
+  resolveRegistryClosure(metadata.readinessManifest, readinessRegistryCategories(transitionSemanticRegistry));
+  const {
+    readinessManifest: _readinessManifest,
+    traceability: _traceability,
+    documentation: _documentation,
+    ...runtimeMetadata
+  } = metadata;
+  const semantics = normalizeRuntimeMetadata(runtimeMetadata as Omit<
+    TransitionDefinitionMetadata,
+    'documentation' | 'readinessManifest' | 'traceability'
+  >);
+  return {
+    semantics,
+    resolvedRegistryEntries: resolveRegistryClosure(semantics, runtimeRegistryCategories(transitionSemanticRegistry)),
+    executableSemantics: defaultExecutableSemantics(),
+  };
+}
+
+/** @deprecated Use runtimeSemanticProjection. */
+export const semanticTransitionProjection = runtimeSemanticProjection;
+
+export function runtimeSemanticFingerprint(
+  metadata: TransitionDefinitionMetadata,
+): string {
+  if (arguments.length !== 1) throw new TypeError('Custom semantic registries are not accepted by installed identity helpers.');
+  return hashCanonical(runtimeSemanticProjection(metadata));
+}
+
+/** @deprecated Protocol-v1 compatibility name. */
+export const semanticTransitionFingerprint = runtimeSemanticFingerprint;
+
+export function definitionManifestProjection(
+  metadata: TransitionDefinitionMetadata,
+  semanticFingerprint: string,
+): DefinitionManifestProjection {
+  if (arguments.length !== 2) throw new TypeError('Installed manifest projection accepts metadata and its runtime fingerprint only.');
+  const readinessManifest = {
+    ...metadata.readinessManifest,
+    limitations: sortRefs(metadata.readinessManifest.limitations),
+    evidence: [...metadata.readinessManifest.evidence]
+      .sort((left, right) => left.evidenceId.localeCompare(right.evidenceId)),
+  };
+  const traceability = {
+    defectIds: sortedStrings(metadata.traceability.defectIds),
+    invariantIds: sortedStrings(metadata.traceability.invariantIds),
+    positiveEvidence: sortedStrings(metadata.traceability.positiveEvidence),
+    hostileEvidence: sortedStrings(metadata.traceability.hostileEvidence),
+  };
+  return {
+    runtimeSemanticFingerprint: semanticFingerprint,
+    readinessManifest,
+    traceability,
+    resolvedReadinessRegistryEntries: resolveRegistryClosure(
+      readinessManifest,
+      readinessRegistryCategories(transitionSemanticRegistry),
+    ),
+  };
+}
+
+export function transitionDefinitionManifestHash(
+  metadata: TransitionDefinitionMetadata,
+  semanticFingerprint = runtimeSemanticFingerprint(metadata),
+): string {
+  if (arguments.length > 2) throw new TypeError('Custom semantic registries are not accepted by installed identity helpers.');
+  return hashCanonical(definitionManifestProjection(metadata, semanticFingerprint));
+}
+
+export const definitionManifestHash = transitionDefinitionManifestHash;
+
+export interface CatalogRuntimeHashEntry {
+  readonly transitionId: TransitionId;
+  readonly runtimeSemanticFingerprint: string;
+}
+
+export function runtimeCatalogHash(
+  definitions: readonly Pick<SerializedTransitionDefinition, 'runtimeSemanticFingerprint' | 'transitionId'>[],
+): string {
+  const transitions: CatalogRuntimeHashEntry[] = definitions
+    .map((definition) => ({
+      transitionId: definition.transitionId,
+      runtimeSemanticFingerprint: definition.runtimeSemanticFingerprint,
+    }))
+    .sort((left, right) => left.transitionId.localeCompare(right.transitionId));
+  return hashCanonical({
+    catalogFormatVersion: TRANSITION_CATALOG_FORMAT_VERSION,
+    lifecycleEpoch: LIFECYCLE_EPOCH,
+    transitions,
+  });
+}
+
+/** @deprecated Use runtimeCatalogHash. */
+export const semanticCatalogHash = runtimeCatalogHash;
+
+export function catalogDefinitionManifestHash(
+  definitions: readonly Pick<SerializedTransitionDefinition, 'definitionManifestHash' | 'transitionId'>[],
+): string {
+  return hashCanonical({
+    catalogFormatVersion: TRANSITION_CATALOG_FORMAT_VERSION,
+    definitions: definitions
+      .map((definition) => ({
+        transitionId: definition.transitionId,
+        definitionManifestHash: definition.definitionManifestHash,
+      }))
+      .sort((left, right) => left.transitionId.localeCompare(right.transitionId)),
+  });
+}
+
+function normalizeRuntimeMetadata(
+  metadata: Omit<TransitionDefinitionMetadata, 'documentation' | 'readinessManifest' | 'traceability'>,
+): unknown {
+  return {
+    ...metadata,
+    sourcePosture: {
+      taskStatuses: sortedStrings(metadata.sourcePosture.taskStatuses),
+      milestoneStatuses: sortedStrings(metadata.sourcePosture.milestoneStatuses),
+      stepStatuses: sortedStrings(metadata.sourcePosture.stepStatuses),
+      correctivePostures: sortedStrings(metadata.sourcePosture.correctivePostures),
+    },
+    inputContract: [...metadata.inputContract]
+      .map((input) => ({ ...input }))
+      .sort((left, right) => refKey(left.input).localeCompare(refKey(right.input))),
+    outputContract: [...metadata.outputContract]
+      .map((output) => ({ ...output }))
+      .sort((left, right) => left.outputId.localeCompare(right.outputId)),
+    guards: metadata.guards.map(normalizeGuard),
+    authority: {
+      ...metadata.authority,
+      eligibleRoles: sortedStrings(metadata.authority.eligibleRoles),
+      principal: {
+        ...metadata.authority.principal,
+        allowedKinds: sortedStrings(metadata.authority.principal.allowedKinds),
+      },
+      capabilities: [...metadata.authority.capabilities]
+        .sort((left, right) => refKey(left.capability).localeCompare(refKey(right.capability))),
+      credentials: sortRefs(metadata.authority.credentials),
+      executionBoundaries: sortedStrings(metadata.authority.executionBoundaries),
+      separationOfDuty: [...metadata.authority.separationOfDuty]
+        .sort((left, right) => left.constraintId.localeCompare(right.constraintId)),
+      forbiddenCombinations: [...metadata.authority.forbiddenCombinations]
+        .map((constraint) => ({ ...constraint, subjects: sortRefs(constraint.subjects) }))
+        .sort((left, right) => left.constraintId.localeCompare(right.constraintId)),
+    },
+    effects: {
+      ...metadata.effects,
+      taskStatus: { ...metadata.effects.taskStatus, from: sortedStrings(metadata.effects.taskStatus.from) },
+      milestoneStatus: { ...metadata.effects.milestoneStatus, from: sortedStrings(metadata.effects.milestoneStatus.from) },
+      stepStatus: { ...metadata.effects.stepStatus, from: sortedStrings(metadata.effects.stepStatus.from) },
+      orderedNodes: metadata.effects.orderedNodes.map(normalizeEffectNode),
+      postconditions: [...metadata.effects.postconditions]
+        .map(normalizePostcondition)
+        .sort((left, right) => left.postconditionId.localeCompare(right.postconditionId)),
+    },
+    admissionBoundary: {
+      ...metadata.admissionBoundary,
+      lock: {
+        ...metadata.admissionBoundary.lock,
+        scope: normalizeProjectionSlice(metadata.admissionBoundary.lock.scope),
+      },
+      orderedRevalidations: metadata.admissionBoundary.orderedRevalidations.map(normalizeRevalidation),
+    },
+    atomicity: {
+      ...metadata.atomicity,
+      executionKey: {
+        ...metadata.atomicity.executionKey,
+        fields: sortProjectionFields(metadata.atomicity.executionKey.fields),
+      },
+      journal: metadata.atomicity.journal.mode === 'none'
+        ? metadata.atomicity.journal
+        : {
+            ...metadata.atomicity.journal,
+            orderedPhases: metadata.atomicity.journal.orderedPhases.map(normalizeJournalPhase),
+          },
+      recovery: metadata.atomicity.recovery.mode === 'manual-integrity-stop'
+        ? {
+            ...metadata.atomicity.recovery,
+            fromPhaseIds: sortedStrings(metadata.atomicity.recovery.fromPhaseIds),
+          }
+        : {
+            ...metadata.atomicity.recovery,
+            fromPhaseIds: sortedStrings(metadata.atomicity.recovery.fromPhaseIds),
+            orderedSteps: metadata.atomicity.recovery.orderedSteps.map((step) => ({ ...step })),
+          },
+      readback: {
+        ...metadata.atomicity.readback,
+        postconditionIds: sortedStrings(metadata.atomicity.readback.postconditionIds),
+      },
+    },
+    racePreconditions: [...metadata.racePreconditions]
+      .map(normalizeRace)
+      .sort((left, right) => left.raceId.localeCompare(right.raceId)),
+  };
+}
+
+function normalizeGuard(guard: TransitionGuardMetadata): unknown {
+  return {
+    ...guard,
+    reads: sortProjectionSlices(guard.reads),
+    requiredInputs: sortRefs(guard.requiredInputs),
+  };
+}
+
+function normalizeEffectNode(node: TransitionEffectNode): unknown {
+  return {
+    ...node,
+    conditions: [...node.conditions].sort((left, right) => conditionKey(left).localeCompare(conditionKey(right))),
+    dependsOn: sortedStrings(node.dependsOn),
+  };
+}
+
+function normalizePostcondition(postcondition: TransitionPostcondition): TransitionPostcondition {
+  return {
+    ...postcondition,
+    reads: sortProjectionSlices(postcondition.reads),
+    effectNodeIds: sortedStrings(postcondition.effectNodeIds),
+  };
+}
+
+function normalizeRevalidation(revalidation: TransitionRevalidation): unknown {
+  return { ...revalidation, reads: sortProjectionSlices(revalidation.reads) };
+}
+
+function normalizeRace(race: RegisteredRacePrecondition): RegisteredRacePrecondition {
+  return {
+    ...race,
+    reads: sortProjectionSlices(race.reads),
+    allowedFailureCodes: sortedStrings(race.allowedFailureCodes),
+  };
+}
+
+function normalizeJournalPhase(phase: TransitionJournalPhase): unknown {
+  return {
+    ...phase,
+    allowedNextPhaseIds: sortedStrings(phase.allowedNextPhaseIds),
+    effectNodeIds: sortedStrings(phase.effectNodeIds),
+    digestFields: sortProjectionFields(phase.digestFields),
+  };
+}
+
+function sortProjectionSlices(slices: readonly ProjectionSliceRef[]): ProjectionSliceRef[] {
+  const grouped = new Map<string, { projection: ProjectionSliceRef['projection']; fieldIds: Set<ProjectionSliceRef['fieldIds'][number]> }>();
+  for (const slice of slices) {
+    const key = refKey(slice.projection);
+    const current = grouped.get(key) ?? { projection: slice.projection, fieldIds: new Set() };
+    slice.fieldIds.forEach((fieldId) => current.fieldIds.add(fieldId));
+    grouped.set(key, current);
+  }
+  return [...grouped.values()]
+    .map((entry) => ({ projection: entry.projection, fieldIds: sortedStrings([...entry.fieldIds]) }))
+    .sort((left, right) => refKey(left.projection).localeCompare(refKey(right.projection)));
+}
+
+function normalizeProjectionSlice(slice: ProjectionSliceRef): ProjectionSliceRef {
+  return { ...slice, fieldIds: sortedStrings(slice.fieldIds) };
+}
+
+function sortProjectionFields(fields: readonly ProjectionFieldRef[]): ProjectionFieldRef[] {
+  return [...fields].sort((left, right) =>
+    `${refKey(left.projection)}\0${left.fieldId}`.localeCompare(`${refKey(right.projection)}\0${right.fieldId}`));
+}
+
+function sortRefs<TRef extends RegisteredRef<string>>(refs: readonly TRef[]): TRef[] {
+  return [...refs].sort((left, right) => refKey(left).localeCompare(refKey(right)));
+}
+
+function sortedStrings<TValue extends string>(values: readonly TValue[]): TValue[] {
+  return [...values].sort((left, right) => left.localeCompare(right));
+}
+
+function conditionKey(condition: EffectCondition): string {
+  return condition.kind === 'input-present'
+    ? `input-present\0${refKey(condition.input)}`
+    : `guard-passed\0${condition.guardId}`;
+}
+
+function refKey(ref: RegisteredRef<string>): string {
+  return `${ref.id}@${ref.version}`;
+}
+
+interface CategorizedRegistryEntry {
+  readonly category: string;
+  readonly entry: VersionedRegistryEntry<string>;
+}
+
+function runtimeRegistryCategories(registry: SemanticRegistry): CategorizedRegistryEntry[] {
+  const categoryNames: readonly RuntimeRegistryCategory[] = [
+    'inputs',
+    'schemas',
+    'projections',
+    'hashPolicies',
+    'identities',
+    'identityComparators',
+    'principalBases',
+    'capabilities',
+    'credentialPolicies',
+    'credentialVerifiers',
+    'clocks',
+    'delegationPolicies',
+    'ownershipPolicies',
+    'guardEvaluators',
+    'effectAdapters',
+    'resources',
+    'lockPolicies',
+    'executionKeyPolicies',
+    'journalSchemas',
+    'journalAdapters',
+    'recoveryAdapters',
+    'readbackAdapters',
+  ];
+  return categoryNames.flatMap((category) => registry[category].map((entry) => ({ category, entry })));
+}
+
+function readinessRegistryCategories(registry: SemanticRegistry): CategorizedRegistryEntry[] {
+  const categoryNames: readonly ReadinessRegistryCategory[] = [
+    'coverageProducers',
+    'coverageProfiles',
+    'limitations',
+    'releaseProfiles',
+    'semanticRules',
+  ];
+  return categoryNames.flatMap((category) => registry[category].map((entry) => ({ category, entry })));
+}
+
+function resolveRegistryClosure(root: unknown, entries: readonly CategorizedRegistryEntry[]): unknown[] {
+  const resolved = new Map<string, CategorizedRegistryEntry>();
+  const pending = findRegisteredRefs(root);
+  while (pending.length > 0) {
+    const ref = pending.pop()!;
+    const key = refKey(ref);
+    if (resolved.has(key)) continue;
+    const matches = entries.filter((entry) => refKey(entry.entry) === key);
+    if (matches.length !== 1) {
+      const error = new TypeError(`Unresolved semantic reference ${key}: expected exact one installed entry, got ${matches.length}.`);
+      Object.assign(error, { code: 'UNRESOLVED_SEMANTIC_REFERENCE', ref: key });
+      throw error;
+    }
+    const candidate = matches[0]!;
+    resolved.set(key, candidate);
+    for (const nested of findRegisteredRefs(candidate.entry)) {
+      if (refKey(nested) !== key) pending.push(nested);
+    }
+  }
+  return [...resolved.values()]
+    .sort((left, right) => `${left.category}\0${refKey(left.entry)}`.localeCompare(`${right.category}\0${refKey(right.entry)}`))
+    .map(({ category, entry }) => ({ category, entry: normalizeRegistryEntry(category, entry) }));
+}
+
+function findRegisteredRefs(value: unknown): RegisteredRef<string>[] {
+  const refs: RegisteredRef<string>[] = [];
+  visit(value);
+  return refs;
+
+  function visit(candidate: unknown): void {
+    if (Array.isArray(candidate)) {
+      candidate.forEach(visit);
+      return;
+    }
+    if (candidate === null || typeof candidate !== 'object') return;
+    const object = candidate as Record<string, unknown>;
+    if (typeof object.id === 'string' && Number.isInteger(object.version)) {
+      refs.push({ id: object.id, version: object.version as number });
+    }
+    Object.values(object).forEach(visit);
+  }
+}
+
+function normalizeRegistryEntry(category: string, entry: VersionedRegistryEntry<string>): unknown {
+  const record = entry as VersionedRegistryEntry<string> & Record<string, unknown>;
+  switch (category) {
+    case 'projections':
+      return { ...record, fieldIds: sortedUnknownStrings(record.fieldIds) };
+    case 'guardEvaluators':
+      return { ...record, allowedInputs: sortUnknownRefs(record.allowedInputs) };
+    case 'credentialPolicies': {
+      const binding = record.binding as ProjectionSliceRef | undefined;
+      return { ...record, binding: binding ? normalizeProjectionSlice(binding) : binding };
+    }
+    case 'identityComparators':
+      return { ...record, operands: sortUnknownRefs(record.operands) };
+    case 'executionKeyPolicies':
+      return { ...record, requiredFields: sortUnknownProjectionFields(record.requiredFields) };
+    case 'lockPolicies': {
+      const scope = record.scope as ProjectionSliceRef | null | undefined;
+      return { ...record, scope: scope ? normalizeProjectionSlice(scope) : scope };
+    }
+    case 'journalAdapters':
+      return { ...record, compatibleEffectAdapters: sortUnknownRefs(record.compatibleEffectAdapters) };
+    case 'recoveryAdapters':
+      return { ...record, compatibleJournalAdapters: sortUnknownRefs(record.compatibleJournalAdapters) };
+    case 'readbackAdapters':
+      return { ...record, compatibleEffectAdapters: sortUnknownRefs(record.compatibleEffectAdapters) };
+    case 'releaseProfiles':
+      return {
+        ...record,
+        allowedLimitations: sortUnknownRefs(record.allowedLimitations),
+        requiredRules: sortUnknownRefs(record.requiredRules),
+      };
+    case 'coverageProfiles':
+      return { ...record, requiredEvidenceKinds: sortedUnknownStrings(record.requiredEvidenceKinds) };
+    default:
+      return record;
+  }
+}
+
+function defaultExecutableSemantics(): unknown {
+  return {
+    rules: coreReleaseRuleDescriptors.map(([id, suffix]) => ({
+      id, version: 1, implementationId: `implementation.release-rule.${suffix}`, implementationVersion: 1,
+    })),
+    bindings: [...correctiveReplanExecutableSemanticIdentity]
+      .sort((left, right) => `${left.category}\0${left.id}@${left.version}`.localeCompare(`${right.category}\0${right.id}@${right.version}`)),
+  };
+}
+
+function sortedUnknownStrings(value: unknown): string[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === 'string')
+    ? [...value].sort((left, right) => left.localeCompare(right))
+    : [];
+}
+
+function sortUnknownRefs(value: unknown): RegisteredRef<string>[] {
+  return Array.isArray(value)
+    ? sortRefs(value.filter((entry): entry is RegisteredRef<string> =>
+        entry !== null
+        && typeof entry === 'object'
+        && typeof (entry as { id?: unknown }).id === 'string'
+        && Number.isInteger((entry as { version?: unknown }).version)))
+    : [];
+}
+
+function sortUnknownProjectionFields(value: unknown): ProjectionFieldRef[] {
+  return Array.isArray(value)
+    ? sortProjectionFields(value.filter((entry): entry is ProjectionFieldRef => {
+        if (entry === null || typeof entry !== 'object') return false;
+        const field = entry as { projection?: unknown; fieldId?: unknown };
+        return typeof field.fieldId === 'string'
+          && field.projection !== null
+          && typeof field.projection === 'object'
+          && typeof (field.projection as { id?: unknown }).id === 'string'
+          && Number.isInteger((field.projection as { version?: unknown }).version);
+      }))
+    : [];
+}

package/src/lifecycle/immutable.ts

@@ -0,0 +1,8 @@
+export function deepFreeze<T>(value: T): T {
+  if (typeof value === 'function') return Object.freeze(value);
+  if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    Object.values(value as Record<string, unknown>).forEach(deepFreeze);
+  }
+  return value;
+}

package/src/lifecycle/implementation-table.ts

@@ -0,0 +1,118 @@
+import type { ExecutableSemanticBinding } from './types.js';
+import { deepFreeze } from './immutable.js';
+
+type Callable = (...arguments_: never[]) => unknown;
+
+export interface CorrectiveReplanImplementationCallables {
+  readonly guards: readonly Callable[];
+  readonly identityComparators: readonly Callable[];
+  readonly verifyReceipt: Callable;
+  readonly acquireTaskLock: Callable;
+  readonly createJournalIntent: Callable;
+  readonly recoverCorrectiveReplan: Callable;
+  readonly executeCorrectiveReplan: Callable;
+  readonly terminalReadback: Callable;
+  readonly canonicalJsonSha256: Callable;
+  readonly rawPlanSha256: Callable;
+}
+
+export const coreReleaseRuleDescriptors = deepFreeze([
+  ['semantic-rule.definition-integrity', 'definition-integrity'],
+  ['semantic-rule.exact-authority', 'exact-authority'],
+  ['semantic-rule.required-inputs', 'required-inputs'],
+  ['semantic-rule.admission-boundary', 'admission-boundary'],
+  ['semantic-rule.reliable-effects', 'reliable-effects'],
+] as const);
+
+const guardSuffixes = [
+  'bindings-current', 'source-posture', 'no-step-in-progress', 'active-decision', 'attempt-threshold',
+  'semantic-plan-change', 'guarded-step-retained', 'actor-role-eligible', 'no-c1-claim', 'no-writer-lease',
+  'plan-validation-passed', 'receipt-valid', 'risk-audit-passed',
+] as const;
+const implementationDescriptors = [
+  ...guardSuffixes.map((suffix) => ['guardEvaluators', `guard-evaluator.task.corrective-replan.${suffix}`, `guard.${suffix}`, 'evaluate'] as const),
+  ['identityComparators', 'identity-comparator.corrective-replan.author-validator', 'identity-comparator.corrective-replan.author-validator', 'compare'],
+  ['identityComparators', 'identity-comparator.corrective-replan.author-risk-auditor', 'identity-comparator.corrective-replan.author-risk-auditor', 'compare'],
+  ['identityComparators', 'identity-comparator.corrective-replan.author-human-principal', 'identity-comparator.corrective-replan.author-human-principal', 'compare'],
+  ['credentialVerifiers', 'credential-verifier.corrective-replan.receipt', 'credential-verifier.corrective-replan.receipt', 'verify'],
+  ['lockPolicies', 'lock-policy.corrective-replan-task-exclusive', 'lock.corrective-replan.task-exclusive', 'execute'],
+  ['effectAdapters', 'effect-adapter.journaled-corrective-replan', 'effect.journaled-corrective-replan', 'execute'],
+  ['journalAdapters', 'journal-adapter.corrective-replan-task', 'journal.corrective-replan.task', 'execute'],
+  ['recoveryAdapters', 'recovery-adapter.corrective-replan-roll-forward', 'recovery.corrective-replan.roll-forward', 'execute'],
+  ['readbackAdapters', 'readback-adapter.corrective-replan-terminal', 'readback.corrective-replan-terminal', 'execute'],
+  ['hashPolicies', 'hash-policy.canonical-json-sha256', 'hash.canonical-json-sha256', 'hash'],
+  ['hashPolicies', 'hash-policy.raw-sha256', 'hash.corrective-plan-raw-sha256', 'hash'],
+] as const;
+
+export const correctiveReplanExecutableSemanticIdentity = deepFreeze(implementationDescriptors.map(
+  ([category, id, semanticSuffix, callableKind]) => ({
+    category,
+    id,
+    version: 1,
+    semanticId: `implementation.${semanticSuffix}`,
+    semanticVersion: 1,
+    wiring: ['credentialVerifiers', 'effectAdapters', 'identityComparators', 'journalAdapters', 'lockPolicies', 'readbackAdapters', 'recoveryAdapters'].includes(category) ? 'invoked' : null,
+    implementationResult: category === 'readbackAdapters' ? 'projected-readback' : null,
+    projectionWiring: category === 'readbackAdapters' ? 'invoked' : null,
+    callableKind,
+  }),
+));
+
+/** Explicit Core-owned implementation inventory. It is intentionally not derived from registry rows. */
+export function createCorrectiveReplanImplementationTable(
+  callables: CorrectiveReplanImplementationCallables,
+): Readonly<Record<string, readonly ExecutableSemanticBinding[]>> {
+  return deepFreeze({
+    guardEvaluators: [
+      ...guardSuffixes.map((suffix, index) => binding(
+        `guard-evaluator.task.corrective-replan.${suffix}`, `guard.${suffix}`, 'evaluate', callables.guards[index]!,
+      )),
+    ],
+    identityComparators: callables.identityComparators.map((callable, index) => {
+      const suffix = ['author-validator', 'author-risk-auditor', 'author-human-principal'][index]!;
+      return binding(`identity-comparator.corrective-replan.${suffix}`, `identity-comparator.corrective-replan.${suffix}`, 'compare', callable);
+    }),
+    credentialVerifiers: [
+      binding('credential-verifier.corrective-replan.receipt', 'credential-verifier.corrective-replan.receipt', 'verify', callables.verifyReceipt),
+    ],
+    lockPolicies: [
+      { ...binding('lock-policy.corrective-replan-task-exclusive', 'lock.corrective-replan.task-exclusive', 'execute', callables.acquireTaskLock), wiring: 'invoked' },
+    ],
+    effectAdapters: [
+      { ...binding('effect-adapter.journaled-corrective-replan', 'effect.journaled-corrective-replan', 'execute', callables.executeCorrectiveReplan), wiring: 'invoked' },
+    ],
+    journalAdapters: [
+      { ...binding('journal-adapter.corrective-replan-task', 'journal.corrective-replan.task', 'execute', callables.createJournalIntent), wiring: 'invoked' },
+    ],
+    recoveryAdapters: [
+      { ...binding('recovery-adapter.corrective-replan-roll-forward', 'recovery.corrective-replan.roll-forward', 'execute', callables.recoverCorrectiveReplan), wiring: 'invoked' },
+    ],
+    readbackAdapters: [
+      {
+        ...binding('readback-adapter.corrective-replan-terminal', 'readback.corrective-replan-terminal', 'execute', callables.terminalReadback),
+        wiring: 'invoked',
+        implementationResult: 'projected-readback',
+        projectionWiring: 'invoked',
+      },
+    ],
+    hashPolicies: [
+      binding('hash-policy.canonical-json-sha256', 'hash.canonical-json-sha256', 'hash', callables.canonicalJsonSha256),
+      binding('hash-policy.raw-sha256', 'hash.corrective-plan-raw-sha256', 'hash', callables.rawPlanSha256),
+    ],
+  });
+}
+
+function binding(
+  id: string,
+  semanticSuffix: string,
+  kind: 'compare' | 'evaluate' | 'execute' | 'hash' | 'verify',
+  callable: Callable,
+): ExecutableSemanticBinding {
+  return {
+    id,
+    version: 1,
+    semanticId: `implementation.${semanticSuffix}`,
+    semanticVersion: 1,
+    [kind]: callable,
+  };
+}

package/src/lifecycle/index.ts

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './evaluator.js';
+export * from './corrective-replan.js';
+export {
+  compileCoreTransitionCatalog,
+  evaluateCoreStaticReadiness,
+  guardedTransitionCatalog,
+} from '../transition-core.js';