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

package/src/transition-core.ts

@@ -0,0 +1,330 @@
+import { WorkflowService } from './workflow.js';
+import { CoreTaskOperationLockManager } from './state/lock.js';
+import { correctiveReplanTerminalReadback, driveCorrectiveReplanTransaction } from './state/corrective-replan-executor.js';
+import { CorrectiveReplanTaskTransactionStore } from './state/corrective-replan-transaction.js';
+import { GuardedTransitionCatalog, validateTransitionDefinitionSemantics } from './lifecycle/catalog.js';
+import { installedAuthoritySemanticBindings, projectAuthoritySemanticBundle, type AuthoritySemanticBinding } from './lifecycle/corrective-replan-authority.js';
+import { correctiveReplanCredentialFunctionBindings, type CredentialFunctionBinding } from './lifecycle/corrective-replan-credential-core.js';
+import { correctiveReplanCredentialSchemaArtifacts, correctiveReplanCredentialSchemaValidators } from './lifecycle/corrective-replan-credential-schema.js';
+import { diagnoseCorrectiveReplanCredentialClosure } from './lifecycle/corrective-replan-credentials.js';
+import { hashCorrectivePlanBytes, taskCorrectiveReplanDefinition } from './lifecycle/corrective-replan.js';
+import { evaluateTransition } from './lifecycle/evaluator.js';
+import {
+  evaluateInstalledReleaseRulesForCore, installedCoreRuleBindings, projectReleaseRuleContextForCore,
+} from './lifecycle/core-static-readiness.js';
+import { hashCanonical, runtimeCatalogHash, runtimeSemanticFingerprint, runtimeSemanticProjection as runtimeProjection, transitionDefinitionManifestHash } from './lifecycle/fingerprint.js';
+import { deepFreeze } from './lifecycle/immutable.js';
+import { createCorrectiveReplanImplementationTable } from './lifecycle/implementation-table.js';
+import {
+  installedPayloadSchemaArtifacts, installedPayloadSchemaValidators,
+  installedTransitionDefinitionArtifact, installedTransitionDefinitionValidator,
+  transitionDefinitionDocumentSha256, transitionDefinitionVocabularySha256,
+} from './lifecycle/schema-artifact.js';
+import { transitionSemanticRegistry } from './lifecycle/semantic-registry.js';
+import {
+  LIFECYCLE_EPOCH, TRANSITION_DEFINITION_FORMAT_VERSION,
+  type CompilerDiagnostic, type CoreCatalogCompileResult, type CoreCompiledCatalogHandle,
+  type CoreCompilerProvenance, type CoreReleaseRuleBinding, type CoreReleaseRuleContext,
+  type ExecutableSemanticBinding, type PayloadSchemaArtifactBinding, type PayloadSchemaValidatorBinding,
+  type SerializedTransitionDefinition, type StaticReadinessReport, type TransitionId,
+} from './lifecycle/types.js';
+
+type Callable = (...arguments_: never[]) => unknown;
+interface BoundPayloadSchema {
+  readonly schema: { readonly id: string; readonly version: number };
+  readonly artifact: PayloadSchemaArtifactBinding;
+  readonly validator: PayloadSchemaValidatorBinding;
+}
+interface BoundRule extends CoreReleaseRuleBinding { readonly context: CoreReleaseRuleContext }
+interface GuardExecutableBinding { readonly guardId: string; readonly semanticVersion: number; readonly implementationId: `implementation.${string}`; readonly implementationVersion: number; readonly callable: Callable }
+interface ExecutableSlot { readonly path: string; readonly binding: ExecutableSemanticBinding }
+export interface TransitionExecutableBinding { readonly transitionId: TransitionId; readonly version: 1; readonly runtimeSemanticFingerprint: string; readonly implementationId: `implementation.${string}`; readonly implementationVersion: number; readonly guardCallables: readonly GuardExecutableBinding[]; readonly executableSlots: readonly ExecutableSlot[]; readonly evaluate: Callable }
+export interface CorePrivateTransitionIr {
+  readonly transitionId: TransitionId;
+  readonly serializedDefinition: SerializedTransitionDefinition;
+  readonly transitionExecutableBinding: TransitionExecutableBinding;
+  readonly authoritySemanticBindings: readonly AuthoritySemanticBinding[];
+  readonly credentialSemanticBindings: readonly CredentialFunctionBinding[];
+  readonly credentialClosureSha256: string;
+  readonly definitionSchema: BoundPayloadSchema;
+  readonly rules: readonly BoundRule[];
+  readonly payloadSchemas: readonly BoundPayloadSchema[];
+  readonly payloadSchemaClosureSha256: string;
+}
+interface CoreRecord { readonly ir: readonly CorePrivateTransitionIr[]; readonly readiness: StaticReadinessReport }
+const guards = taskCorrectiveReplanDefinition.guards.map((guard) => guard.evaluate) as readonly Callable[];
+const credentialReceiptVerifier = correctiveReplanCredentialFunctionBindings.find(
+  (entry) => entry.id === 'credential-verifier.corrective-replan.receipt',
+);
+if (!credentialReceiptVerifier) throw new TypeError('Installed corrective-replan receipt verifier is missing.');
+const credentialClosure = diagnoseCorrectiveReplanCredentialClosure();
+if (!credentialClosure.closed) throw new TypeError('Installed corrective-replan credential bundle is not closed.');
+const executableTable = createCorrectiveReplanImplementationTable({
+  guards,
+  identityComparators: installedAuthoritySemanticBindings.filter((entry) => entry.kind === 'identity-comparator').map((entry) => entry.callable) as readonly Callable[],
+  verifyReceipt: credentialReceiptVerifier.callable as Callable,
+  acquireTaskLock: CoreTaskOperationLockManager.prototype.acquire as Callable,
+  createJournalIntent: CorrectiveReplanTaskTransactionStore.prototype.createIntent as Callable,
+  recoverCorrectiveReplan: driveCorrectiveReplanTransaction as Callable,
+  executeCorrectiveReplan: WorkflowService.prototype.executeCorrectiveReplan as Callable,
+  terminalReadback: correctiveReplanTerminalReadback as Callable,
+  canonicalJsonSha256: hashCanonical, rawPlanSha256: hashCorrectivePlanBytes,
+});
+const installedExecutables = deepFreeze(Object.values(executableTable).flat());
+const installedFamilySemantics = runtimeProjection(taskCorrectiveReplanDefinition.metadata).semantics;
+const installedTransitionExecutableBinding = deepFreeze({
+  transitionId: taskCorrectiveReplanDefinition.metadata.transitionId, version: 1,
+  runtimeSemanticFingerprint: taskCorrectiveReplanDefinition.runtimeSemanticFingerprint,
+  implementationId: 'implementation.transition.task-corrective-replan', implementationVersion: 2,
+  guardCallables: taskCorrectiveReplanDefinition.guards.map((guard, index) => {
+    const binding = executable(taskCorrectiveReplanDefinition.metadata.guards[index]!.evaluator);
+    return { guardId: guard.metadata.guardId, semanticVersion: guard.metadata.semanticVersion,
+      implementationId: binding.semanticId, implementationVersion: binding.semanticVersion, callable: guard.evaluate };
+  }),
+  executableSlots: declaredExecutableSlots(), evaluate: evaluateTransition as Callable,
+}) as TransitionExecutableBinding;
+export const installedTransitionExecutableBindings = deepFreeze([installedTransitionExecutableBinding]);
+const issuedCatalogs = new WeakMap<object, CoreRecord>();
+
+export const guardedTransitionCatalog = deepFreeze(new GuardedTransitionCatalog([taskCorrectiveReplanDefinition]));
+
+export function compileCoreTransitionCatalog(raw: readonly unknown[]): CoreCatalogCompileResult {
+  if (!Array.isArray(raw)) return failed([{ diagnosticId: 'compiler.catalog.input-invalid', path: '/', message: 'Core catalog input must be an array.' }]);
+  const diagnostics = diagnoseClosure(raw, installedCoreRuleBindings, installedTransitionExecutableBindings, installedPayloadSchemaArtifacts, installedPayloadSchemaValidators);
+  if (diagnostics.length > 0) return failed(diagnostics);
+  const ir: CorePrivateTransitionIr[] = [];
+  const seen = new Set<string>();
+  for (const candidate of raw) {
+    const definition = structuredClone(candidate) as SerializedTransitionDefinition;
+    if (seen.has(definition.transitionId)) {
+      diagnostics.push({ diagnosticId: 'compiler.catalog.transition-duplicate', path: '/transitionId', ref: definition.transitionId, message: 'Transition ID is duplicated.' });
+      continue;
+    }
+    seen.add(definition.transitionId);
+    const payloadSchemas = bindPayloadSchemas(definition, installedPayloadSchemaArtifacts, installedPayloadSchemaValidators, diagnostics);
+    const rules = installedCoreRuleBindings.map((binding) => ({ ...binding, context: projectReleaseRuleContextForCore(definition, binding.id) }));
+    const payloadSchemaClosureSha256 = hashCanonical(payloadSchemas.map(projectPayloadBinding));
+    const definitionSchema = { schema: { id: installedTransitionDefinitionArtifact.id, version: 1 },
+      artifact: installedTransitionDefinitionArtifact, validator: installedTransitionDefinitionValidator };
+    ir.push(deepFreeze({ transitionId: definition.transitionId, serializedDefinition: definition,
+      transitionExecutableBinding: installedTransitionExecutableBinding, authoritySemanticBindings: installedAuthoritySemanticBindings,
+      credentialSemanticBindings: correctiveReplanCredentialFunctionBindings,
+      credentialClosureSha256: credentialClosure.closureSha256,
+      definitionSchema, rules, payloadSchemas, payloadSchemaClosureSha256 }));
+  }
+  if (diagnostics.length > 0) return failed(diagnostics);
+  ir.sort((left, right) => left.transitionId.localeCompare(right.transitionId));
+  const frozenIr = deepFreeze(ir);
+  const readiness = readinessFromIr(frozenIr);
+  const serialized = frozenIr.map((entry) => entry.serializedDefinition);
+  const order = frozenIr.map((entry) => semanticOrder(entry.serializedDefinition));
+  const canonicalIr = frozenIr.map(projectPrivateIr);
+  const provenance: CoreCompilerProvenance = {
+    compilerId: 'codex-workflow-exact-family-compiler', compilerVersion: '4.0.0',
+    compilerBuildSha256: hashCanonical({ implementation: 'corrective-replan-exact-family', version: 2 }),
+    definitionFormatVersion: TRANSITION_DEFINITION_FORMAT_VERSION, lifecycleEpoch: LIFECYCLE_EPOCH,
+    rawCatalogSha256: hashCanonical(serialized), runtimeCatalogHash: runtimeCatalogHash(serialized),
+    staticCatalogHash: hashCanonical(readiness),
+    semanticRegistryClosureSha256: hashCanonical(canonicalIr.map((entry) => entry.registryClosure)),
+    executableRegistryClosureSha256: hashCanonical(canonicalIr.map((entry) => entry.transitionExecutableBinding)),
+    transitionSchemaArtifactSha256: transitionDefinitionDocumentSha256,
+    transitionSchemaVocabularySha256: transitionDefinitionVocabularySha256,
+    transitionSchemaValidatorSha256: hashCanonical(projectPayloadValidator(installedTransitionDefinitionValidator)),
+    payloadSchemaClosureSha256: frozenIr[0]?.payloadSchemaClosureSha256 ?? hashCanonical([]),
+    officialProfileSha256: hashCanonical({}),
+    ruleSetSha256: hashCanonical(installedCoreRuleBindings.map(projectRule)),
+    canonicalOrderSha256: hashCanonical(order), irSha256: hashCanonical({ transitions: canonicalIr, order, readiness }),
+  };
+  const catalog = deepFreeze({ kind: 'core-compiled-transition-catalog', provenance,
+    transitions: frozenIr.map((entry) => ({ transitionId: entry.transitionId,
+      runtimeSemanticFingerprint: entry.serializedDefinition.runtimeSemanticFingerprint,
+      definitionManifestHash: entry.serializedDefinition.definitionManifestHash })) }) as CoreCompiledCatalogHandle;
+  issuedCatalogs.set(catalog, deepFreeze({ ir: frozenIr, readiness }));
+  return { ok: true, catalog, diagnostics: [], diagnosticsHash: hashCanonical([]) };
+}
+
+export function evaluateCoreStaticReadiness(catalog: CoreCompiledCatalogHandle): StaticReadinessReport {
+  return requireRecord(catalog).readiness;
+}
+
+export function inspectCorePrivateIr(catalog: CoreCompiledCatalogHandle): readonly CorePrivateTransitionIr[] {
+  return requireRecord(catalog).ir;
+}
+
+export function diagnoseCoreIssuanceClosure(input: {
+  readonly definitions: readonly unknown[];
+  readonly ruleBindings?: readonly CoreReleaseRuleBinding[];
+  readonly transitionExecutableBindings?: readonly TransitionExecutableBinding[];
+  readonly authoritySemanticBindings?: readonly AuthoritySemanticBinding[];
+  readonly schemaArtifacts?: readonly PayloadSchemaArtifactBinding[];
+  readonly schemaValidators?: readonly PayloadSchemaValidatorBinding[];
+}) {
+  const diagnostics = diagnoseClosure(input.definitions, input.ruleBindings ?? installedCoreRuleBindings,
+    input.transitionExecutableBindings ?? installedTransitionExecutableBindings,
+    input.schemaArtifacts ?? installedPayloadSchemaArtifacts, input.schemaValidators ?? installedPayloadSchemaValidators,
+    input.authoritySemanticBindings ?? installedAuthoritySemanticBindings);
+  const ordered = orderDiagnostics(diagnostics);
+  return deepFreeze({ issuable: ordered.length === 0, diagnostics: ordered, diagnosticsHash: hashCanonical(ordered) });
+}
+
+function diagnoseClosure(definitions: readonly unknown[], rules: readonly CoreReleaseRuleBinding[], transitionBindings: readonly TransitionExecutableBinding[], artifacts: readonly PayloadSchemaArtifactBinding[], validators: readonly PayloadSchemaValidatorBinding[], authorityBindings: readonly AuthoritySemanticBinding[] = installedAuthoritySemanticBindings): CompilerDiagnostic[] {
+  const diagnostics: CompilerDiagnostic[] = [];
+  exactRules(rules, diagnostics);
+  exactTransitionBindings(transitionBindings, diagnostics);
+  exactAuthorityBindings(authorityBindings, diagnostics);
+  for (const raw of definitions) {
+    if (!installedTransitionDefinitionArtifact || !installedTransitionDefinitionValidator.callable(raw)) {
+      diagnostics.push({ diagnosticId: 'compiler.schema.document-invalid', path: '/', message: 'Definition fails the installed root schema.' });
+      continue;
+    }
+    const semantic = validateTransitionDefinitionSemantics(raw as SerializedTransitionDefinition);
+    semantic.issues.forEach((entry) => diagnostics.push(entry.ref === undefined
+      ? { diagnosticId: `compiler.semantic.${entry.ruleId.slice('validation.'.length)}`, path: entry.path, message: entry.message }
+      : { diagnosticId: `compiler.semantic.${entry.ruleId.slice('validation.'.length)}`, path: entry.path, ref: entry.ref, message: entry.message }));
+    const definition = raw as SerializedTransitionDefinition;
+    if (definition.transitionId !== 'task.plan.corrective-replan') diagnostics.push({ diagnosticId: 'compiler.family.unsupported', path: '/transitionId', ref: definition.transitionId, message: 'No installed exact family compiler.' });
+    try {
+      const metadata = stripHashes(definition);
+      const mismatch = firstDifferencePath(installedFamilySemantics, runtimeProjection(metadata).semantics);
+      if (mismatch) diagnostics.push({ diagnosticId: 'core.transition-binding.semantic-mismatch', path: mismatch, ref: definition.transitionId, message: `Definition semantics differ from the installed exact family at ${mismatch}.` });
+      if (runtimeSemanticFingerprint(metadata) !== definition.runtimeSemanticFingerprint) diagnostics.push({ diagnosticId: 'compiler.fingerprint.runtime-mismatch', path: '/runtimeSemanticFingerprint', message: 'Runtime fingerprint is stale.' });
+      if (transitionDefinitionManifestHash(metadata, definition.runtimeSemanticFingerprint) !== definition.definitionManifestHash) diagnostics.push({ diagnosticId: 'compiler.fingerprint.manifest-mismatch', path: '/definitionManifestHash', message: 'Manifest hash is stale.' });
+    } catch (error) {
+      const ref = (error as { ref?: string }).ref;
+      diagnostics.push(ref === undefined
+        ? { diagnosticId: 'compiler.registry.reference-unresolved', path: '/', message: error instanceof Error ? error.message : String(error) }
+        : { diagnosticId: 'compiler.registry.reference-unresolved', path: '/', ref, message: error instanceof Error ? error.message : String(error) });
+    }
+    bindPayloadSchemas(definition, artifacts, validators, diagnostics);
+  }
+  return diagnostics;
+}
+
+function exactRules(candidate: readonly CoreReleaseRuleBinding[], diagnostics: CompilerDiagnostic[]): void {
+  for (const installed of installedCoreRuleBindings) {
+    const matches = candidate.filter((entry) => sameRef(entry, installed));
+    if (matches.length !== 1) diagnostics.push({ diagnosticId: matches.length === 0 ? 'core.rule-binding.missing' : 'core.rule-binding.duplicate', path: `/ruleBindings/${installed.id}`, ref: refKey(installed), message: `${installed.id} must be bound exactly once.` });
+    else if (matches[0] !== installed || matches[0]!.callable !== installed.callable
+      || matches[0]!.implementationId !== installed.implementationId || matches[0]!.implementationVersion !== installed.implementationVersion) {
+      diagnostics.push({ diagnosticId: 'core.rule-binding.callable-substituted', path: `/ruleBindings/${installed.id}`, ref: refKey(installed), message: `${installed.id} callable differs from installed Core identity.` });
+    }
+  }
+}
+
+function exactAuthorityBindings(candidate: readonly AuthoritySemanticBinding[], diagnostics: CompilerDiagnostic[]): void {
+  const issue = (id: string, installed: AuthoritySemanticBinding) => diagnostics.push({ diagnosticId: `core.authority-binding.${id}`,
+    path: `/authoritySemanticBindings/${installed.id}`, ref: installed.id, message: `${installed.id} authority callable differs from Core.` });
+  for (const installed of installedAuthoritySemanticBindings) {
+    const matches = candidate.filter((entry) => sameRef(entry, installed));
+    if (matches.length !== 1) issue(matches.length === 0 ? 'missing' : 'duplicate', installed);
+    else if (typeof matches[0]!.callable !== 'function') issue('callable-missing', installed);
+    else if (matches[0] !== installed || matches[0]!.callable !== installed.callable) issue('callable-substituted', installed);
+  }
+  candidate.filter((entry) => !installedAuthoritySemanticBindings.some((installed) => sameRef(entry, installed)))
+    .forEach((entry) => issue('extra', entry));
+}
+
+function exactTransitionBindings(candidate: readonly TransitionExecutableBinding[], diagnostics: CompilerDiagnostic[]): void {
+  const expected = installedTransitionExecutableBinding;
+  const matches = candidate.filter((entry) => entry.transitionId === expected.transitionId);
+  const issue = (id: string, path: string, ref: string) => diagnostics.push({ diagnosticId: `core.transition-binding.${id}`, path, ref, message: `Exact transition binding mismatch: ${ref}.` });
+  if (matches.length !== 1) issue(matches.length === 0 ? 'missing' : 'duplicate', `/transitionExecutableBindings/${expected.transitionId}`, expected.transitionId);
+  candidate.filter((entry) => entry.transitionId !== expected.transitionId).forEach((entry) => issue('extra', '/transitionExecutableBindings', entry.transitionId));
+  if (matches.length !== 1 || matches[0] === expected) return;
+  const actual = matches[0]!;
+  expected.guardCallables.filter((guard) => !actual.guardCallables.some((entry) => entry.guardId === guard.guardId)).forEach((guard) => issue('guard-missing', '/transitionExecutableBindings/guards', guard.guardId));
+  actual.guardCallables.filter((guard) => !expected.guardCallables.some((entry) => entry.guardId === guard.guardId) || actual.guardCallables.filter((entry) => entry.guardId === guard.guardId).length > 1).forEach((guard) => issue('guard-extra', '/transitionExecutableBindings/guards', guard.guardId));
+  if (actual.guardCallables.map((entry) => entry.guardId).join('\0') !== expected.guardCallables.map((entry) => entry.guardId).join('\0')) issue('guard-order-mismatch', '/transitionExecutableBindings/guards', expected.transitionId);
+  expected.guardCallables.forEach((guard, index) => { const entry = actual.guardCallables[index]; if (entry?.guardId === guard.guardId && (entry.callable !== guard.callable || entry.semanticVersion !== guard.semanticVersion || entry.implementationId !== guard.implementationId || entry.implementationVersion !== guard.implementationVersion)) issue('guard-callable-substituted', `/transitionExecutableBindings/guards/${index}`, guard.guardId); });
+  if (actual.version !== expected.version) issue('semantic-mismatch', '/transitionExecutableBindings/version', expected.transitionId);
+  if (actual.runtimeSemanticFingerprint !== expected.runtimeSemanticFingerprint || actual.evaluate !== expected.evaluate || actual.implementationId !== expected.implementationId || actual.implementationVersion !== expected.implementationVersion || actual.executableSlots !== expected.executableSlots) issue('semantic-mismatch', '/transitionExecutableBindings', expected.transitionId);
+}
+
+function bindPayloadSchemas(definition: SerializedTransitionDefinition, artifacts: readonly PayloadSchemaArtifactBinding[], validators: readonly PayloadSchemaValidatorBinding[], diagnostics: CompilerDiagnostic[]): BoundPayloadSchema[] {
+  let schemaRefs: { id: string; version: number }[] = [];
+  try {
+    const closure = runtimeSemanticProjectionForCore(stripHashes(definition));
+    schemaRefs = closure.filter((entry) => entry.category === 'schemas').map((entry) => entry.entry as { id: string; version: number });
+  } catch { return []; }
+  return schemaRefs.map((schema) => {
+    const installedArtifact = onlyInstalled(installedPayloadSchemaArtifacts, schema)!;
+    const installedValidator = onlyInstalled(installedPayloadSchemaValidators, schema)!;
+    const artifactMatches = artifacts.filter((entry) => sameRef(entry, schema));
+    const validatorMatches = validators.filter((entry) => sameRef(entry, schema));
+    if (artifactMatches.length !== 1) diagnostics.push({ diagnosticId: artifactMatches.length === 0 ? 'core.payload-artifact.missing' : 'core.payload-artifact.duplicate', path: `/schemaArtifacts/${schema.id}`, ref: refKey(schema), message: `${schema.id} artifact must occur exactly once.` });
+    else if (artifactMatches[0] !== installedArtifact) diagnostics.push({ diagnosticId: 'core.payload-artifact.subschema-substituted', path: `/schemaArtifacts/${schema.id}`, ref: refKey(schema), message: `${schema.id} artifact identity or subschema differs from Core.` });
+    if (validatorMatches.length !== 1) diagnostics.push({ diagnosticId: validatorMatches.length === 0 ? 'core.payload-validator.missing' : 'core.payload-validator.duplicate', path: `/schemaValidators/${schema.id}`, ref: refKey(schema), message: `${schema.id} validator must occur exactly once.` });
+    else if (validatorMatches[0] !== installedValidator || validatorMatches[0]!.callable !== installedValidator.callable) diagnostics.push({ diagnosticId: 'core.payload-validator.callable-substituted', path: `/schemaValidators/${schema.id}`, ref: refKey(schema), message: `${schema.id} validator differs from Core.` });
+    return { schema, artifact: installedArtifact, validator: installedValidator };
+  });
+}
+
+function runtimeSemanticProjectionForCore(metadata: ReturnType<typeof stripHashes>) {
+  return (runtimeProjection(metadata).resolvedRegistryEntries as { category: string; entry: unknown }[]);
+}
+
+function readinessFromIr(ir: readonly CorePrivateTransitionIr[]): StaticReadinessReport {
+  const transitions = ir.map((entry) => ({ transitionId: entry.transitionId,
+    blockers: [...evaluateInstalledReleaseRulesForCore(entry.rules)] }));
+  const content = { staticReady: ir.length > 0 && transitions.every((entry) => entry.blockers.length === 0),
+    catalogBlockers: ir.length === 0 ? ['static.catalog.empty'] : [], transitions };
+  return deepFreeze({ ...content, reportHash: hashCanonical(content) });
+}
+
+function semanticOrder(definition: SerializedTransitionDefinition) {
+  return { transitionId: definition.transitionId, guards: definition.guards.map((entry) => entry.guardId),
+    effects: definition.effects.orderedNodes.map((entry) => ({ id: entry.effectId, ordinal: entry.ordinal, dependsOn: entry.dependsOn })),
+    revalidations: definition.admissionBoundary.orderedRevalidations.map((entry) => ({ id: entry.revalidationId, ordinal: entry.ordinal })) };
+}
+function projectPrivateIr(ir: CorePrivateTransitionIr) {
+  const runtime = runtimeProjection(stripHashes(ir.serializedDefinition));
+  return { transitionId: ir.transitionId, semantics: runtime.semantics, registryClosure: runtime.resolvedRegistryEntries,
+    transitionExecutableBinding: projectTransitionBinding(ir.transitionExecutableBinding), authoritySemanticBundle: projectAuthoritySemanticBundle(ir.authoritySemanticBindings),
+    credentialSemanticBundle: {
+      manifestSha256: credentialClosure.manifestSha256,
+      closureSha256: ir.credentialClosureSha256,
+      artifacts: correctiveReplanCredentialSchemaArtifacts.map(({ document: _document, ...entry }) => entry),
+      validators: correctiveReplanCredentialSchemaValidators.map(({ callable: _callable, ...entry }) => entry),
+      functions: ir.credentialSemanticBindings.map(({ callable: _callable, ...entry }) => entry),
+    },
+    definitionSchema: projectPayloadBinding(ir.definitionSchema), rules: ir.rules.map(projectRule),
+    payloadSchemas: ir.payloadSchemas.map(projectPayloadBinding), blockers: evaluateInstalledReleaseRulesForCore(ir.rules) };
+}
+function projectTransitionBinding(entry: TransitionExecutableBinding) { return { transitionId: entry.transitionId, version: entry.version, runtimeSemanticFingerprint: entry.runtimeSemanticFingerprint, implementationId: entry.implementationId, implementationVersion: entry.implementationVersion, guards: entry.guardCallables.map(({ callable: _callable, ...guard }) => guard), executableSlots: entry.executableSlots.map((slot) => ({ path: slot.path, binding: projectExecutable(slot.binding) })) }; }
+function projectExecutable(entry: ExecutableSemanticBinding) { return { id: entry.id, version: entry.version, semanticId: entry.semanticId, semanticVersion: entry.semanticVersion, wiring: entry.wiring ?? null, implementationResult: entry.implementationResult ?? null, projectionWiring: entry.projectionWiring ?? null }; }
+function projectRule(entry: CoreReleaseRuleBinding) { return { id: entry.id, version: entry.version, implementationId: entry.implementationId, implementationVersion: entry.implementationVersion }; }
+function projectPayloadBinding(entry: BoundPayloadSchema) { return { schema: entry.schema, artifact: projectPayloadArtifact(entry.artifact), validator: projectPayloadValidator(entry.validator) }; }
+function projectPayloadArtifact(entry: PayloadSchemaArtifactBinding) { return { id: entry.id, version: entry.version, implementationId: entry.implementationId, implementationVersion: entry.implementationVersion, documentSha256: entry.documentSha256, schemaPointer: entry.schemaPointer, subschemaSha256: entry.subschemaSha256 }; }
+function projectPayloadValidator(entry: PayloadSchemaValidatorBinding) { return { id: entry.id, version: entry.version, implementationId: entry.implementationId, implementationVersion: entry.implementationVersion, artifactSha256: entry.artifactSha256, subschemaSha256: entry.subschemaSha256 }; }
+function stripHashes(definition: SerializedTransitionDefinition) { const { runtimeSemanticFingerprint: _r, semanticFingerprint: _s, definitionManifestHash: _m, ...metadata } = definition; return metadata; }
+function onlyInstalled<T extends { id: string; version: number }>(entries: readonly T[], ref: { id: string; version: number }): T | undefined { const matches = entries.filter((entry) => sameRef(entry, ref)); return matches.length === 1 ? matches[0] : undefined; }
+function sameRef(left: { id: string; version: number }, right: { id: string; version: number }): boolean { return left.id === right.id && left.version === right.version; }
+function refKey(ref: { id: string; version: number }): string { return `${ref.id}@${ref.version}`; }
+function executable(ref: { id: string; version: number }): ExecutableSemanticBinding { const matches = installedExecutables.filter((entry) => sameRef(entry, ref)); if (matches.length !== 1) throw new TypeError(`Installed executable ${refKey(ref)} is not exact-one.`); return matches[0]!; }
+function declaredExecutableSlots(): ExecutableSlot[] {
+  const metadata = taskCorrectiveReplanDefinition.metadata;
+  const refs: Array<readonly [string, { id: string; version: number }]> = [
+    ...metadata.guards.map((guard, index) => [`/guards/${index}/evaluator`, guard.evaluator] as const),
+    ...metadata.effects.orderedNodes.map((effect, index) => [`/effects/orderedNodes/${index}/adapter`, effect.adapter] as const),
+    ...metadata.admissionBoundary.orderedRevalidations.map((entry, index) => [`/admissionBoundary/orderedRevalidations/${index}/evaluator`, entry.evaluator] as const),
+    ...metadata.authority.separationOfDuty.map((constraint, index) => [`/authority/separationOfDuty/${index}/comparator`, constraint.comparator] as const),
+    ...metadata.authority.forbiddenCombinations.map((constraint, index) => [`/authority/forbiddenCombinations/${index}/comparator`, constraint.comparator] as const),
+    ['/authority/credentialVerifier', { id: 'credential-verifier.corrective-replan.receipt', version: 1 }],
+    ['/admissionBoundary/lock/policy', metadata.admissionBoundary.lock.policy],
+    ['/atomicity/journal/adapter', metadata.atomicity.journal.mode === 'required' ? metadata.atomicity.journal.adapter : { id: 'journal-adapter.unreachable', version: 1 }],
+    ['/atomicity/recovery/adapter', metadata.atomicity.recovery.mode !== 'manual-integrity-stop' ? metadata.atomicity.recovery.adapter : { id: 'recovery-adapter.unreachable', version: 1 }],
+    ['/executorAdapter', metadata.executorAdapter], ['/atomicity/executionKey/hashPolicy', metadata.atomicity.executionKey.hashPolicy],
+    ['/atomicity/readback/adapter', metadata.atomicity.readback.adapter], ['/atomicity/readback/resultDigestPolicy', metadata.atomicity.readback.resultDigestPolicy],
+  ];
+  metadata.inputContract.forEach((contract, index) => { const input = transitionSemanticRegistry.inputs.find((entry) => sameRef(entry, contract.input)); if (input?.hashPolicy) refs.push([`/inputContract/${index}/hashPolicy`, input.hashPolicy]); });
+  return refs.map(([path, ref]) => ({ path, binding: executable(ref) }));
+}
+function firstDifferencePath(left: unknown, right: unknown, path = ''): string | null {
+  if (Object.is(left, right)) return null;
+  if (Array.isArray(left) && Array.isArray(right)) { for (let index = 0; index < Math.max(left.length, right.length); index += 1) { const mismatch = firstDifferencePath(left[index], right[index], `${path}/${index}`); if (mismatch) return mismatch; } return null; }
+  if (left !== null && right !== null && typeof left === 'object' && typeof right === 'object') { for (const key of [...new Set([...Object.keys(left), ...Object.keys(right)])].filter((entry) => entry !== 'description').sort()) { const mismatch = firstDifferencePath((left as Record<string, unknown>)[key], (right as Record<string, unknown>)[key], `${path}/${key}`); if (mismatch) return mismatch; } return null; }
+  return path || '/';
+}
+function requireRecord(catalog: CoreCompiledCatalogHandle): CoreRecord { const record = catalog !== null && typeof catalog === 'object' ? issuedCatalogs.get(catalog) : undefined; if (!record) { const error = new TypeError('Invalid compiled provenance: catalog was not issued by Workflow Core.'); Object.assign(error, { code: 'INVALID_COMPILED_PROVENANCE' }); throw error; } return record; }
+function failed(diagnostics: readonly CompilerDiagnostic[]): CoreCatalogCompileResult { const ordered = orderDiagnostics(diagnostics); return { ok: false, diagnostics: ordered, diagnosticsHash: hashCanonical(ordered) }; }
+function orderDiagnostics(diagnostics: readonly CompilerDiagnostic[]) { return [...diagnostics].sort((left, right) => `${left.path}\0${left.diagnosticId}\0${left.ref ?? ''}`.localeCompare(`${right.path}\0${right.diagnosticId}\0${right.ref ?? ''}`)); }

package/src/ulid.ts

@@ -0,0 +1,24 @@
+import { randomBytes } from 'node:crypto';
+
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+function encode(value: bigint, length: number): string {
+  let result = '';
+  for (let index = 0; index < length; index += 1) {
+    result = ALPHABET[Number(value & 31n)] + result;
+    value >>= 5n;
+  }
+  return result;
+}
+
+export function createUlid(now = Date.now()): string {
+  const timestamp = encode(BigInt(now), 10);
+  const random = randomBytes(10);
+  let randomValue = 0n;
+  for (const byte of random) randomValue = (randomValue << 8n) | BigInt(byte);
+  return `${timestamp}${encode(randomValue, 16)}`;
+}
+
+export function createEntityId(prefix: 'DISC' | 'TASK' | 'MS' | 'DGR', now = Date.now()): string {
+  return `${prefix}-${createUlid(now)}`;
+}

package/src/version.ts

@@ -0,0 +1,2 @@
+export const PACKAGE_NAME = 'codex-workflow-v2';
+export const PACKAGE_VERSION = '2.0.0-beta.14';

package/src/workflow-blocker-route.ts

@@ -0,0 +1,109 @@
+import { isCliCommand } from './cli-actions.js';
+import { hashCanonical } from './lifecycle/fingerprint.js';
+
+type ObjectValue = Record<string, unknown>;
+const object = (value: unknown): ObjectValue =>
+  value !== null && typeof value === 'object' && !Array.isArray(value) ? value as ObjectValue : {};
+
+export function nextBetaPatchVersion(version: string): string {
+  const beta = /^(.*-beta(?:\.\d+)*\.)(\d+)$/u.exec(version);
+  if (beta) return `${beta[1]}${Number(beta[2]) + 1}`;
+  const stable = /^(\d+)\.(\d+)\.(\d+)$/u.exec(version);
+  if (stable) return `${stable[1]}.${stable[2]}.${Number(stable[3]) + 1}`;
+  throw new TypeError(`Workflow package version has no incrementable patch: ${version}`);
+}
+
+function requiresHuman(next: ObjectValue): boolean {
+  const visit = (value: unknown): boolean => {
+    if (Array.isArray(value)) return value.some(visit);
+    const record = object(value);
+    return Object.entries(record).some(([key, child]) =>
+      ((key === 'humanApprovalRequired' || key === 'productDecisionRequired') && child === true)
+      || (key === 'requiredHumanGate' && child !== null && child !== undefined)
+      || visit(child));
+  };
+  return visit(next);
+}
+
+/**
+ * Describes a cross-project incident when Core has no executable, repair, or Human route.
+ * The descriptor grants no authority: gateway/App orchestration owns chat creation and release work.
+ */
+export function withWorkflowBlockerRoute(next: ObjectValue, packageVersion: string): ObjectValue {
+  const observation = object(next.observation);
+  const route = object(next.route);
+  const blockedAction = next.blockedAction;
+  if (next.action !== 'doctor'
+    || typeof blockedAction !== 'string'
+    || !isCliCommand(blockedAction)
+    || observation.kind !== 'assessment'
+    || observation.availableRepairTransitionId !== null
+    || observation.repair !== null
+    || route.actionSupport !== 'unwitnessed'
+    || requiresHuman(next)) return next;
+
+  const patchVersion = nextBetaPatchVersion(packageVersion);
+  const source = {
+    scope: typeof next.scope === 'string' ? next.scope : null,
+    id: typeof next.id === 'string' ? next.id : null,
+    revision: Number.isInteger(next.revision) ? next.revision : null,
+    status: typeof next.status === 'string' ? next.status : null,
+    stepId: typeof next.stepId === 'string' ? next.stepId : null,
+    action: 'doctor',
+    blockedAction,
+    routeId: typeof route.routeId === 'string' ? route.routeId : null,
+    routeFingerprint: typeof route.routeFingerprint === 'string' ? route.routeFingerprint : null,
+    reasonCodes: Array.isArray(observation.reasonCodes)
+      ? observation.reasonCodes.filter((value): value is string => typeof value === 'string')
+      : [],
+  };
+  const blockerId = hashCanonical({ domain: 'codex-workflow/workflow-blocker-route/v1', packageVersion, source });
+  return {
+    ...next,
+    workflowBlockerRoute: {
+      schemaVersion: 1,
+      state: 'gateway-confirmation-required',
+      blockerId,
+      packageVersion,
+      source,
+      confirmation: {
+        required: true,
+        checks: [
+          'Refresh status and next without mutation.',
+          'Confirm that no executable Core, repair, or Human route exists.',
+          'Confirm that the responsible product chat is not actively progressing the blocked action.',
+        ],
+      },
+      dispatch: {
+        owner: 'originating-coordinator-via-gateway',
+        projectName: 'codex-workflow-v2',
+        chatType: 'workflow-blocker',
+        title: patchVersion,
+        modelRequest: { phase: 'implementation', complexity: 'complex', highRisk: false },
+        requiredPacketFields: [
+          'blockerId', 'packageVersion', 'sourceProject', 'sourceThreadId', 'source',
+          'freshStatusHash', 'freshNextHash', 'repositoryState', 'expectedContinuation',
+        ],
+      },
+      patchChatResponsibilities: [
+        'Reproduce and identify the state-machine cause.',
+        'Implement the smallest general fix and regression coverage.',
+        'Run release checks and publish the exact patch version.',
+        'Send a closed callback report to the originating Coordinator without being polled.',
+      ],
+      callback: {
+        target: 'originating-coordinator-thread',
+        requiredFields: [
+          'blockerId', 'publishedVersion', 'verification', 'downstreamUpdateRoute',
+          'expectedFreshNext', 'residualBlockers',
+        ],
+      },
+      authority: {
+        core: ['describe', 'bind-current-navigation', 'suggest-patch-version'],
+        coordinator: ['confirm', 'dispatch', 'verify-created-instructions', 'receive-callback', 'resume-product'],
+        patchChat: ['analyze', 'implement', 'verify', 'publish', 'send-callback'],
+        coreEffects: 'none',
+      },
+    },
+  };
+}