@kontextmind/kxm 0.7.40 → 0.7.43

package/plugins/kxm/src/{vnext-engine-plan.ts → engine-plan.ts}

@@ -1,23 +1,23 @@
 import { createHash } from "node:crypto";
-import { vnextCanonicalJson, vnextPortablePath, type JsonObject, type JsonValue } from "./vnext-config.ts";
+import { kxmCanonicalJson, kxmPortablePath, type JsonObject, type JsonValue } from "./project-config.ts";
 import {
-  VNEXT_COMPILED_WORKFLOW_SCHEMA,
-  type VnextCompiledAssignments,
-  type VnextCompiledEvidence,
-  type VnextCompiledJoin,
-  type VnextCompiledPlan,
-  type VnextCompiledStep,
-  type VnextCompiledTransition,
-  type VnextRepositoryAccess,
-} from "./vnext-engine-compile.ts";
+  KXM_COMPILED_WORKFLOW_SCHEMA,
+  type KxmCompiledAssignments,
+  type KxmCompiledEvidence,
+  type KxmCompiledJoin,
+  type KxmCompiledPlan,
+  type KxmCompiledStep,
+  type KxmCompiledTransition,
+  type KxmRepositoryAccess,
+} from "./engine-compile.ts";
 import {
-  VNEXT_ABSENT_MEMORY_REVISION,
+  KXM_ABSENT_MEMORY_REVISION,
   runtimeError,
-  type VnextRunEventStore,
-  type VnextRunRecord,
-} from "./vnext-runtime-store.ts";
+  type KxmRunEventStore,
+  type KxmRunRecord,
+} from "./runtime-store.ts";
 
-export const VNEXT_RUN_PLAN_SCHEMA = "kxm.run-plan.v2";
+export const KXM_RUN_PLAN_SCHEMA = "kxm.run-plan.v2";
 const SUPPORTED_KINDS = new Set(["agent", "moa", "gate", "approval", "wait"]);
 const TERMINAL = new Set(["completed", "failed", "cancelled"]);
 const JOIN_STRATEGIES = new Set(["all", "all-settled", "quorum", "first-success"]);
@@ -58,19 +58,19 @@ const JOIN_OPTIONAL = ["minimumPassed", "cancelRemaining"] as const;
 const EVIDENCE_REQUIRED = ["key", "kind", "minimum", "reusableAcrossAttempts"] as const;
 const EVIDENCE_OPTIONAL = ["producerPolicy"] as const;
 
-export type VnextGateDefinition =
+export type KxmGateDefinition =
   | { readonly kind: "command"; readonly argv: readonly string[]; readonly timeoutMs: number; readonly cwd?: "control" }
   | { readonly kind: "artifacts-exist"; readonly paths: readonly string[] }
   | { readonly kind: "reserved" };
 
-export interface VnextPinnedGates {
+export interface KxmPinnedGates {
   readonly registry: { readonly schema: typeof GATE_REGISTRY_SCHEMA; readonly hash: string } | null;
-  readonly definitions: Readonly<Record<string, VnextGateDefinition>>;
+  readonly definitions: Readonly<Record<string, KxmGateDefinition>>;
   readonly controlRoot: { readonly repositoryId: "control"; readonly projectKey: string };
 }
 
-export interface VnextRunPlanEnvelope {
-  readonly schema: typeof VNEXT_RUN_PLAN_SCHEMA;
+export interface KxmRunPlanEnvelope {
+  readonly schema: typeof KXM_RUN_PLAN_SCHEMA;
   readonly runId: string;
   readonly projectId: string;
   readonly homeRuntimeId: string;
@@ -86,20 +86,20 @@ export interface VnextRunPlanEnvelope {
     readonly maxRunDurationMs?: number;
     readonly maxAgentTimeMs?: number;
   };
-  readonly plan: VnextCompiledPlan;
-  readonly gates: VnextPinnedGates;
+  readonly plan: KxmCompiledPlan;
+  readonly gates: KxmPinnedGates;
 }
 
-export function vnextSha256(input: string): string {
+export function kxmSha256(input: string): string {
   return `sha256:${createHash("sha256").update(input, "utf8").digest("hex")}`;
 }
 
-export function hashVnextRunPlanEnvelope(envelope: VnextRunPlanEnvelope): string {
-  return vnextSha256(vnextCanonicalJson(envelope as unknown as JsonValue));
+export function hashKxmRunPlanEnvelope(envelope: KxmRunPlanEnvelope): string {
+  return kxmSha256(kxmCanonicalJson(envelope as unknown as JsonValue));
 }
 
-export function freezeVnextCompiledPlan(plan: VnextCompiledPlan): VnextCompiledPlan {
-  const steps = Object.create(null) as Record<string, VnextCompiledStep>;
+export function freezeKxmCompiledPlan(plan: KxmCompiledPlan): KxmCompiledPlan {
+  const steps = Object.create(null) as Record<string, KxmCompiledStep>;
   for (const id of plan.order) {
     const step = plan.steps[id];
     if (!step) throw runtimeError("run_plan_corrupt", plan.workflowId, `compiled plan is missing step ${id}`);
@@ -113,14 +113,14 @@ export function freezeVnextCompiledPlan(plan: VnextCompiledPlan): VnextCompiledP
   });
 }
 
-function freezeStep(step: VnextCompiledStep): VnextCompiledStep {
-  const transitions = Object.create(null) as Record<string, VnextCompiledTransition>;
+function freezeStep(step: KxmCompiledStep): KxmCompiledStep {
+  const transitions = Object.create(null) as Record<string, KxmCompiledTransition>;
   for (const outcome of step.outcomes) {
     const transition = step.transitions[outcome];
     if (!transition) throw runtimeError("run_plan_corrupt", step.id, `compiled plan is missing transition ${outcome}`);
     transitions[outcome] = { ...transition };
   }
-  const repositories = Object.create(null) as Record<string, VnextRepositoryAccess>;
+  const repositories = Object.create(null) as Record<string, KxmRepositoryAccess>;
   for (const [id, access] of Object.entries(step.repositories)) repositories[id] = access;
   return deepFreeze({
     ...step,
@@ -138,7 +138,7 @@ function freezeStep(step: VnextCompiledStep): VnextCompiledStep {
   });
 }
 
-export function parseVnextRunPlanEnvelope(raw: string, run: VnextRunRecord, expectedHash: string): VnextRunPlanEnvelope {
+export function parseKxmRunPlanEnvelope(raw: string, run: KxmRunRecord, expectedHash: string): KxmRunPlanEnvelope {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw) as unknown;
@@ -146,22 +146,22 @@ export function parseVnextRunPlanEnvelope(raw: string, run: VnextRunRecord, expe
     throw runtimeError("run_plan_corrupt", run.runId, "run plan envelope is not JSON");
   }
   const envelope = parseEnvelope(parsed, run);
-  const hash = hashVnextRunPlanEnvelope(envelope);
+  const hash = hashKxmRunPlanEnvelope(envelope);
   if (hash !== expectedHash) {
     throw runtimeError("run_plan_corrupt", run.runId, "run plan envelope hash does not match");
   }
   return envelope;
 }
 
-export function rehydrateVnextCompiledPlanFromStore(store: VnextRunEventStore, run: VnextRunRecord): VnextCompiledPlan {
+export function rehydrateKxmCompiledPlanFromStore(store: KxmRunEventStore, run: KxmRunRecord): KxmCompiledPlan {
   return loadPinnedEnvelope(store, run).plan;
 }
 
-export function loadVnextRunPlanEnvelope(store: VnextRunEventStore, run: VnextRunRecord): VnextRunPlanEnvelope {
+export function loadKxmRunPlanEnvelope(store: KxmRunEventStore, run: KxmRunRecord): KxmRunPlanEnvelope {
   return loadPinnedEnvelope(store, run);
 }
 
-function loadPinnedEnvelope(store: VnextRunEventStore, run: VnextRunRecord): VnextRunPlanEnvelope {
+function loadPinnedEnvelope(store: KxmRunEventStore, run: KxmRunRecord): KxmRunPlanEnvelope {
   const row = store.runPlan(run.runId);
   if (!row) throw runtimeError("run_plan_missing", run.runId, "run has no pinned plan");
   const events = store.events(run.runId, 0, row.pinnedSequence);
@@ -170,17 +170,17 @@ function loadPinnedEnvelope(store: VnextRunEventStore, run: VnextRunRecord): Vne
   if (typeof eventHash !== "string" || eventHash !== row.runPlanHash) {
     throw runtimeError("run_plan_corrupt", run.runId, "pinned runPlanHash does not match the plan row");
   }
-  return parseVnextRunPlanEnvelope(row.envelope, run, row.runPlanHash);
+  return parseKxmRunPlanEnvelope(row.envelope, run, row.runPlanHash);
 }
 
 export function absentMemoryRevision(): string {
-  return VNEXT_ABSENT_MEMORY_REVISION;
+  return KXM_ABSENT_MEMORY_REVISION;
 }
 
-function parseEnvelope(parsed: unknown, run: VnextRunRecord): VnextRunPlanEnvelope {
+function parseEnvelope(parsed: unknown, run: KxmRunRecord): KxmRunPlanEnvelope {
   const value = asObject(parsed, run.runId, "run plan envelope");
   assertExactKeys(value, ENVELOPE_REQUIRED, [], run.runId, "run plan envelope");
-  if (value.schema !== VNEXT_RUN_PLAN_SCHEMA) {
+  if (value.schema !== KXM_RUN_PLAN_SCHEMA) {
     throw runtimeError("run_plan_corrupt", run.runId, "schema is not kxm.run-plan.v2");
   }
   const runId = asString(value.runId, run.runId, "runId");
@@ -208,14 +208,14 @@ function parseEnvelope(parsed: unknown, run: VnextRunRecord): VnextRunPlanEnvelo
   }
   const limitsValue = asObject(value.projectLimits, run.runId, "projectLimits");
   assertExactKeys(limitsValue, PROJECT_LIMIT_REQUIRED, PROJECT_LIMIT_OPTIONAL, run.runId, "projectLimits");
-  const projectLimits: VnextRunPlanEnvelope["projectLimits"] = {
+  const projectLimits: KxmRunPlanEnvelope["projectLimits"] = {
     maxConcurrentRuns: asCount(limitsValue.maxConcurrentRuns, run.runId, "projectLimits.maxConcurrentRuns"),
     ...(limitsValue.maxRunDurationMs !== undefined ? { maxRunDurationMs: asDuration(limitsValue.maxRunDurationMs, run.runId, "projectLimits.maxRunDurationMs") } : {}),
     ...(limitsValue.maxAgentTimeMs !== undefined ? { maxAgentTimeMs: asDuration(limitsValue.maxAgentTimeMs, run.runId, "projectLimits.maxAgentTimeMs") } : {}),
   };
-  const plan = freezeVnextCompiledPlan(parseCompiledPlan(value.plan, run.runId));
+  const plan = freezeKxmCompiledPlan(parseCompiledPlan(value.plan, run.runId));
   return {
-    schema: VNEXT_RUN_PLAN_SCHEMA,
+    schema: KXM_RUN_PLAN_SCHEMA,
     runId,
     projectId,
     homeRuntimeId,
@@ -227,7 +227,7 @@ function parseEnvelope(parsed: unknown, run: VnextRunRecord): VnextRunPlanEnvelo
   };
 }
 
-function parseGates(raw: unknown, plan: VnextCompiledPlan, runId: string): VnextPinnedGates {
+function parseGates(raw: unknown, plan: KxmCompiledPlan, runId: string): KxmPinnedGates {
   const value = asObject(raw, runId, "gates");
   assertExactKeys(value, GATES_REQUIRED, [], runId, "gates");
   const referenced = new Set<string>();
@@ -251,14 +251,14 @@ function parseGates(raw: unknown, plan: VnextCompiledPlan, runId: string): Vnext
       throw runtimeError("run_plan_corrupt", runId, `definition ${gateId} is not referenced`);
     }
   }
-  const definitions = Object.create(null) as Record<string, VnextGateDefinition>;
+  const definitions = Object.create(null) as Record<string, KxmGateDefinition>;
   for (const gateId of defined) {
     definitions[gateId] = parseGateDefinition(definitionsValue[gateId], gateId, runId);
   }
   return { registry, definitions, controlRoot };
 }
 
-function parseRegistryPin(raw: unknown, runId: string, required: boolean): VnextPinnedGates["registry"] {
+function parseRegistryPin(raw: unknown, runId: string, required: boolean): KxmPinnedGates["registry"] {
   if (raw === null) {
     if (required) throw runtimeError("run_plan_corrupt", runId, "gate steps require a non-null registry pin");
     return null;
@@ -275,7 +275,7 @@ function parseRegistryPin(raw: unknown, runId: string, required: boolean): Vnext
   return { schema: GATE_REGISTRY_SCHEMA, hash };
 }
 
-function parseControlRoot(raw: unknown, runId: string): VnextPinnedGates["controlRoot"] {
+function parseControlRoot(raw: unknown, runId: string): KxmPinnedGates["controlRoot"] {
   const value = asObject(raw, runId, "gates.controlRoot");
   assertExactKeys(value, CONTROL_ROOT_REQUIRED, [], runId, "gates.controlRoot");
   const repositoryId = asString(value.repositoryId, runId, "gates.controlRoot.repositoryId");
@@ -285,7 +285,7 @@ function parseControlRoot(raw: unknown, runId: string): VnextPinnedGates["contro
   return { repositoryId: "control", projectKey: asString(value.projectKey, runId, "gates.controlRoot.projectKey") };
 }
 
-export function parseGateDefinition(raw: unknown, gateId: string, runId: string): VnextGateDefinition {
+export function parseGateDefinition(raw: unknown, gateId: string, runId: string): KxmGateDefinition {
   const value = asObject(raw, runId, `gates.definitions.${gateId}`);
   const kind = asString(value.kind, runId, `gates.definitions.${gateId}.kind`);
   if (kind === "command") {
@@ -327,7 +327,7 @@ export function parseGateDefinition(raw: unknown, gateId: string, runId: string)
       throw runtimeError("run_plan_corrupt", runId, `gates.definitions.${gateId}.paths are not unique`);
     }
     for (const path of paths) {
-      if (path === "." || !vnextPortablePath(path) || path.startsWith("/") || path.includes("\\")) {
+      if (path === "." || !kxmPortablePath(path) || path.startsWith("/") || path.includes("\\")) {
         throw runtimeError("run_plan_corrupt", runId, `gates.definitions.${gateId} path is not a portable relative path`);
       }
     }
@@ -340,10 +340,10 @@ export function parseGateDefinition(raw: unknown, gateId: string, runId: string)
   throw runtimeError("run_plan_corrupt", runId, `gates.definitions.${gateId} kind is invalid`);
 }
 
-function freezeGates(gates: VnextPinnedGates): VnextPinnedGates {
-  const definitions = Object.create(null) as Record<string, VnextGateDefinition>;
+function freezeGates(gates: KxmPinnedGates): KxmPinnedGates {
+  const definitions = Object.create(null) as Record<string, KxmGateDefinition>;
   for (const [id, definition] of Object.entries(gates.definitions)) {
-    definitions[id] = deepFreeze({ ...definition, ...(definition.kind === "command" ? { argv: [...definition.argv] } : {}), ...(definition.kind === "artifacts-exist" ? { paths: [...definition.paths] } : {}) } as VnextGateDefinition);
+    definitions[id] = deepFreeze({ ...definition, ...(definition.kind === "command" ? { argv: [...definition.argv] } : {}), ...(definition.kind === "artifacts-exist" ? { paths: [...definition.paths] } : {}) } as KxmGateDefinition);
   }
   return deepFreeze({
     registry: gates.registry ? { ...gates.registry } : null,
@@ -352,10 +352,10 @@ function freezeGates(gates: VnextPinnedGates): VnextPinnedGates {
   });
 }
 
-function parseCompiledPlan(raw: unknown, runId: string): VnextCompiledPlan {
+function parseCompiledPlan(raw: unknown, runId: string): KxmCompiledPlan {
   const value = asObject(raw, runId, "compiled plan");
   assertExactKeys(value, PLAN_REQUIRED, PLAN_OPTIONAL, runId, "compiled plan");
-  if (value.schema !== VNEXT_COMPILED_WORKFLOW_SCHEMA) {
+  if (value.schema !== KXM_COMPILED_WORKFLOW_SCHEMA) {
     throw runtimeError("run_plan_corrupt", runId, "compiled plan schema is not kxm.compiled-workflow.v1");
   }
   const order = asStringArray(value.order, runId, "order");
@@ -364,7 +364,7 @@ function parseCompiledPlan(raw: unknown, runId: string): VnextCompiledPlan {
   if (!sameSet(stepIds, order)) {
     throw runtimeError("run_plan_corrupt", runId, "compiled plan step keys do not equal order");
   }
-  const steps = Object.create(null) as Record<string, VnextCompiledStep>;
+  const steps = Object.create(null) as Record<string, KxmCompiledStep>;
   for (const stepId of order) {
     steps[stepId] = parseStep(stepsValue[stepId], stepId, runId);
   }
@@ -374,7 +374,7 @@ function parseCompiledPlan(raw: unknown, runId: string): VnextCompiledPlan {
   }
   const limitsObject = asObject(value.limits, runId, "limits");
   assertExactKeys(limitsObject, [], LIMIT_OPTIONAL, runId, "limits");
-  const limits: VnextCompiledPlan["limits"] = {
+  const limits: KxmCompiledPlan["limits"] = {
     ...(limitsObject.maxTransitions !== undefined ? { maxTransitions: asCount(limitsObject.maxTransitions, runId, "limits.maxTransitions") } : {}),
     ...(limitsObject.maxRunDurationMs !== undefined ? { maxRunDurationMs: asDuration(limitsObject.maxRunDurationMs, runId, "limits.maxRunDurationMs") } : {}),
     ...(limitsObject.maxAgentTimeMs !== undefined ? { maxAgentTimeMs: asDuration(limitsObject.maxAgentTimeMs, runId, "limits.maxAgentTimeMs") } : {}),
@@ -385,8 +385,8 @@ function parseCompiledPlan(raw: unknown, runId: string): VnextCompiledPlan {
   for (const stageId of requirePlanHash) {
     if (!steps[stageId]) throw runtimeError("run_plan_corrupt", runId, `requirePlanHash references unknown step ${stageId}`);
   }
-  const plan: VnextCompiledPlan = {
-    schema: VNEXT_COMPILED_WORKFLOW_SCHEMA,
+  const plan: KxmCompiledPlan = {
+    schema: KXM_COMPILED_WORKFLOW_SCHEMA,
     workflowId: asString(value.workflowId, runId, "workflowId"),
     ...(value.sourcePath !== undefined ? { sourcePath: asStringAllowEmpty(value.sourcePath, runId, "sourcePath") } : {}),
     coordinator: asString(value.coordinator, runId, "coordinator"),
@@ -403,7 +403,7 @@ function parseCompiledPlan(raw: unknown, runId: string): VnextCompiledPlan {
   return plan;
 }
 
-function parseStep(raw: unknown, stepId: string, runId: string): VnextCompiledStep {
+function parseStep(raw: unknown, stepId: string, runId: string): KxmCompiledStep {
   const value = asObject(raw, runId, `step ${stepId}`);
   const kind = asString(value.kind, runId, `${stepId}.kind`);
   if (!SUPPORTED_KINDS.has(kind)) {
@@ -431,17 +431,17 @@ function parseStep(raw: unknown, stepId: string, runId: string): VnextCompiledSt
   if (!sameSet(Object.keys(transitionsValue), outcomes)) {
     throw runtimeError("run_plan_corrupt", runId, `step ${stepId} transition keys do not equal outcomes`);
   }
-  const transitions = Object.create(null) as Record<string, VnextCompiledTransition>;
+  const transitions = Object.create(null) as Record<string, KxmCompiledTransition>;
   for (const outcome of outcomes) {
     transitions[outcome] = parseTransition(transitionsValue[outcome], stepId, outcome, runId);
   }
   const repositoriesValue = asObject(value.repositories, runId, `${stepId}.repositories`);
-  const repositories = Object.create(null) as Record<string, VnextRepositoryAccess>;
+  const repositories = Object.create(null) as Record<string, KxmRepositoryAccess>;
   for (const [repositoryId, access] of Object.entries(repositoriesValue)) {
     if (typeof access !== "string" || !REPOSITORY_ACCESS.has(access)) {
       throw runtimeError("run_plan_corrupt", runId, `step ${stepId} repository ${repositoryId} has invalid access`);
     }
-    repositories[repositoryId] = access as VnextRepositoryAccess;
+    repositories[repositoryId] = access as KxmRepositoryAccess;
   }
   const base = {
     id,
@@ -480,7 +480,7 @@ function parseStep(raw: unknown, stepId: string, runId: string): VnextCompiledSt
   return { ...base, kind: "approval" };
 }
 
-function parseTransition(raw: unknown, stepId: string, outcome: string, runId: string): VnextCompiledTransition {
+function parseTransition(raw: unknown, stepId: string, outcome: string, runId: string): KxmCompiledTransition {
   const value = asObject(raw, runId, `${stepId}.${outcome}`);
   const to = asString(value.to, runId, `${stepId}.${outcome}.to`);
   const maxTransitions = value.maxTransitions !== undefined
@@ -514,7 +514,7 @@ function parseTransition(raw: unknown, stepId: string, outcome: string, runId: s
   throw runtimeError("run_plan_corrupt", runId, `step ${stepId} transition ${outcome} is not a discriminated transition`);
 }
 
-function parseAssignments(raw: unknown, stepId: string, runId: string): VnextCompiledAssignments {
+function parseAssignments(raw: unknown, stepId: string, runId: string): KxmCompiledAssignments {
   const value = asObject(raw, runId, `${stepId}.assignments`);
   assertExactKeys(value, ASSIGNMENT_REQUIRED, ASSIGNMENT_OPTIONAL, runId, `${stepId}.assignments`);
   const distinctBy = asStringArray(value.distinctBy, runId, `${stepId}.assignments.distinctBy`);
@@ -535,7 +535,7 @@ function parseAssignments(raw: unknown, stepId: string, runId: string): VnextCom
   };
 }
 
-function parseJoin(raw: unknown, stepId: string, runId: string): VnextCompiledJoin {
+function parseJoin(raw: unknown, stepId: string, runId: string): KxmCompiledJoin {
   const value = asObject(raw, runId, `${stepId}.join`);
   assertExactKeys(value, JOIN_REQUIRED, JOIN_OPTIONAL, runId, `${stepId}.join`);
   const strategy = asString(value.strategy, runId, `${stepId}.join.strategy`);
@@ -543,13 +543,13 @@ function parseJoin(raw: unknown, stepId: string, runId: string): VnextCompiledJo
     throw runtimeError("run_plan_corrupt", runId, `step ${stepId} join strategy is invalid`);
   }
   return {
-    strategy: strategy as VnextCompiledJoin["strategy"],
+    strategy: strategy as KxmCompiledJoin["strategy"],
     ...(value.minimumPassed !== undefined ? { minimumPassed: asCount(value.minimumPassed, runId, `${stepId}.join.minimumPassed`) } : {}),
     ...(value.cancelRemaining !== undefined ? { cancelRemaining: asBoolean(value.cancelRemaining, runId, `${stepId}.join.cancelRemaining`) } : {}),
   };
 }
 
-function parseEvidence(raw: unknown, stepId: string, index: number, runId: string): VnextCompiledEvidence {
+function parseEvidence(raw: unknown, stepId: string, index: number, runId: string): KxmCompiledEvidence {
   const value = asObject(raw, runId, `${stepId}.requiredEvidence[${index}]`);
   assertExactKeys(value, EVIDENCE_REQUIRED, EVIDENCE_OPTIONAL, runId, `${stepId}.requiredEvidence[${index}]`);
   const kind = asString(value.kind, runId, `${stepId}.requiredEvidence[${index}].kind`);
@@ -558,14 +558,14 @@ function parseEvidence(raw: unknown, stepId: string, index: number, runId: strin
   }
   return {
     key: asString(value.key, runId, `${stepId}.requiredEvidence[${index}].key`),
-    kind: kind as VnextCompiledEvidence["kind"],
+    kind: kind as KxmCompiledEvidence["kind"],
     minimum: asCount(value.minimum, runId, `${stepId}.requiredEvidence[${index}].minimum`),
     reusableAcrossAttempts: asBoolean(value.reusableAcrossAttempts, runId, `${stepId}.requiredEvidence[${index}].reusableAcrossAttempts`),
     ...(value.producerPolicy !== undefined ? { producerPolicy: parseProducerPolicy(value.producerPolicy, stepId, runId) } : {}),
   };
 }
 
-function parseProducerPolicy(raw: unknown, stepId: string, runId: string): NonNullable<VnextCompiledEvidence["producerPolicy"]> {
+function parseProducerPolicy(raw: unknown, stepId: string, runId: string): NonNullable<KxmCompiledEvidence["producerPolicy"]> {
   const value = asObject(raw, runId, `${stepId}.producerPolicy`);
   assertExactKeys(value, ["minimumProducers", "eligibleAgents", "acceptedStatuses"], ["degradation"], runId, `${stepId}.producerPolicy`);
   const accepted = value.acceptedStatuses;
@@ -588,7 +588,7 @@ function parseProducerPolicy(raw: unknown, stepId: string, runId: string): NonNu
 
 function parseOracle(
   raw: unknown,
-  steps: Readonly<Record<string, VnextCompiledStep>>,
+  steps: Readonly<Record<string, KxmCompiledStep>>,
   runId: string,
   label: string,
 ): { stageId: string; evidenceKey: string } {