@kontextmind/kxm 0.7.40 → 0.7.44

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

@@ -1,8 +1,8 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { createHash } from "node:crypto";
-import type { VnextGateObservationInput } from "./vnext-engine-gate-records.ts";
-import type { VnextGateErrorClass, VnextGateStopCause } from "./vnext-runtime-store.ts";
-import { runtimeError } from "./vnext-runtime-store.ts";
+import type { KxmGateObservationInput } from "./engine-gate-records.ts";
+import type { KxmGateErrorClass, KxmGateStopCause } from "./runtime-store.ts";
+import { runtimeError } from "./runtime-store.ts";
 import { assertCommandSeatbelt } from "./safety-integrity.ts";
 
 const MAX_DIRECT_TIMER_MS = 2_147_483_647;
@@ -10,47 +10,47 @@ export const COMMAND_TERM_GRACE_MS = 2000;
 export const COMMAND_FINAL_WAIT_MS = 2000;
 export const COMMAND_LINGER_MS = 2000;
 
-export interface VnextCommandDefinition {
+export interface KxmCommandDefinition {
   readonly kind: "command";
   readonly argv: readonly string[];
   readonly timeoutMs: number;
   readonly cwd?: "control";
 }
 
-export interface VnextCommandGateSeams {
+export interface KxmCommandGateSeams {
   timing?: { termGraceMs?: number; finalWaitMs?: number; lingerMs?: number } | undefined;
-  beforeSpawn?: ((definition: VnextCommandDefinition) => void) | undefined;
+  beforeSpawn?: ((definition: KxmCommandDefinition) => void) | undefined;
   afterSpawned?: ((pid: number) => void) | undefined;
-  afterStopRequested?: ((cause: VnextGateStopCause) => void) | undefined;
+  afterStopRequested?: ((cause: KxmGateStopCause) => void) | undefined;
   afterChildClose?: (() => void) | undefined;
 }
 
-export const vnextCommandGateSeams: VnextCommandGateSeams = {};
+export const kxmCommandGateSeams: KxmCommandGateSeams = {};
 
-export type VnextCommandOutcome =
-  | { kind: "no-start"; observation: VnextGateObservationInput }
-  | { kind: "complete"; observation: VnextGateObservationInput }
-  | { kind: "uncertain"; reason: string; observation: VnextGateObservationInput };
+export type KxmCommandOutcome =
+  | { kind: "no-start"; observation: KxmGateObservationInput }
+  | { kind: "complete"; observation: KxmGateObservationInput }
+  | { kind: "uncertain"; reason: string; observation: KxmGateObservationInput };
 
 /**
  * Post-spawn ChildProcess `error` is an uncertain stopCause `error`.
  * The fold reason enum has no post-spawn spawn-error member, so the closed
  * classification keeps errorClass `stream-error` rather than adding a store enum.
  */
-export const POST_SPAWN_CHILD_ERROR_CLASS: VnextGateErrorClass = "stream-error";
+export const POST_SPAWN_CHILD_ERROR_CLASS: KxmGateErrorClass = "stream-error";
 
-export interface VnextCommandObserver {
-  requestStop(cause: VnextGateStopCause, errorClass?: VnextGateErrorClass): void;
+export interface KxmCommandObserver {
+  requestStop(cause: KxmGateStopCause, errorClass?: KxmGateErrorClass): void;
   beginBoundedCleanup(): void;
-  run(): Promise<VnextCommandOutcome>;
+  run(): Promise<KxmCommandOutcome>;
 }
 
 export function createCommandObserver(input: {
-  definition: VnextCommandDefinition;
+  definition: KxmCommandDefinition;
   cwd: string;
   signal: AbortSignal;
   onSpawned: (pid: number) => void;
-}): VnextCommandObserver {
+}): KxmCommandObserver {
   return new CommandObserver(input);
 }
 
@@ -70,8 +70,8 @@ class StreamDigest {
   }
 }
 
-class CommandObserver implements VnextCommandObserver {
-  private readonly definition: VnextCommandDefinition;
+class CommandObserver implements KxmCommandObserver {
+  private readonly definition: KxmCommandDefinition;
   private readonly cwd: string;
   private readonly signal: AbortSignal;
   private readonly onSpawned: (pid: number) => void;
@@ -88,9 +88,9 @@ class CommandObserver implements VnextCommandObserver {
   private closeObserved = 0 as 0 | 1;
   private exitCode: number | null = null;
   private signalName: string | null = null;
-  private stopCause: VnextGateStopCause = "none";
+  private stopCause: KxmGateStopCause = "none";
   private signalsAttempted: "none" | "term" | "term-kill" = "none";
-  private errorClass: VnextGateErrorClass | null = null;
+  private errorClass: KxmGateErrorClass | null = null;
   private startedAt: string;
   private finishedAt: string | null = null;
   private readonly startedMono = process.hrtime.bigint();
@@ -100,11 +100,11 @@ class CommandObserver implements VnextCommandObserver {
   private termTimer: NodeJS.Timeout | undefined;
   private finalTimer: NodeJS.Timeout | undefined;
   private lingerTimer: NodeJS.Timeout | undefined;
-  private resolveOutcome: ((outcome: VnextCommandOutcome) => void) | undefined;
+  private resolveOutcome: ((outcome: KxmCommandOutcome) => void) | undefined;
   private readonly abortListener: () => void;
 
   constructor(input: {
-    definition: VnextCommandDefinition;
+    definition: KxmCommandDefinition;
     cwd: string;
     signal: AbortSignal;
     onSpawned: (pid: number) => void;
@@ -113,7 +113,7 @@ class CommandObserver implements VnextCommandObserver {
     this.cwd = input.cwd;
     this.signal = input.signal;
     this.onSpawned = input.onSpawned;
-    const timing = vnextCommandGateSeams.timing;
+    const timing = kxmCommandGateSeams.timing;
     this.termGraceMs = clampTimer(timing?.termGraceMs ?? COMMAND_TERM_GRACE_MS);
     this.finalWaitMs = clampTimer(timing?.finalWaitMs ?? COMMAND_FINAL_WAIT_MS);
     this.lingerMs = clampTimer(timing?.lingerMs ?? COMMAND_LINGER_MS);
@@ -121,12 +121,12 @@ class CommandObserver implements VnextCommandObserver {
     this.abortListener = () => this.requestStop("cancel");
   }
 
-  requestStop(cause: VnextGateStopCause, errorClass?: VnextGateErrorClass): void {
+  requestStop(cause: KxmGateStopCause, errorClass?: KxmGateErrorClass): void {
     if (cause === "none") return;
     if (this.stopCause === "none") {
       this.stopCause = cause;
       if (errorClass && this.errorClass === null) this.errorClass = errorClass;
-      vnextCommandGateSeams.afterStopRequested?.(cause);
+      kxmCommandGateSeams.afterStopRequested?.(cause);
       this.clearTimer("linger");
       this.beginSignalSequence();
       return;
@@ -139,7 +139,7 @@ class CommandObserver implements VnextCommandObserver {
     this.requestStop("error", "lost-close");
   }
 
-  run(): Promise<VnextCommandOutcome> {
+  run(): Promise<KxmCommandOutcome> {
     return new Promise((resolve) => {
       this.resolveOutcome = resolve;
       try {
@@ -161,7 +161,7 @@ class CommandObserver implements VnextCommandObserver {
       return;
     }
     try {
-      vnextCommandGateSeams.beforeSpawn?.(this.definition);
+      kxmCommandGateSeams.beforeSpawn?.(this.definition);
     } catch {
       this.finishNoStart("validation");
       return;
@@ -279,9 +279,9 @@ class CommandObserver implements VnextCommandObserver {
       this.clearTimer("timeout");
       child.stdout?.destroy();
       child.stderr?.destroy();
-      dropVnextCommandStopCapability(this);
+      dropKxmCommandStopCapability(this);
       try {
-        vnextCommandGateSeams.afterChildClose?.();
+        kxmCommandGateSeams.afterChildClose?.();
       } catch {
         // test seam
       }
@@ -306,7 +306,7 @@ class CommandObserver implements VnextCommandObserver {
       this.requestStop("error", "recording-error");
     }
     try {
-      vnextCommandGateSeams.afterSpawned?.(this.observedPid);
+      kxmCommandGateSeams.afterSpawned?.(this.observedPid);
     } catch {
       this.requestStop("error", "recording-error");
     }
@@ -429,7 +429,7 @@ class CommandObserver implements VnextCommandObserver {
     });
   }
 
-  private uncertaintyReason(observation: VnextGateObservationInput): string {
+  private uncertaintyReason(observation: KxmGateObservationInput): string {
     // Requested primary cause is independent of the later observed exit signal.
     // Signal-termination is only for an externally signalled exit with no earlier request.
     if (this.stopCause === "timeout") return "timeout";
@@ -443,7 +443,7 @@ class CommandObserver implements VnextCommandObserver {
     return "stop-error";
   }
 
-  private snapshot(): VnextGateObservationInput {
+  private snapshot(): KxmGateObservationInput {
     return this.baseObservation({
       completeness: "complete",
       spawned: this.spawnSeen,
@@ -466,11 +466,11 @@ class CommandObserver implements VnextCommandObserver {
   }
 
   private baseObservation(
-    facts: Omit<VnextGateObservationInput, "checkedCount" | "failedCount" | "elapsedMs" | "startedAt"> & {
+    facts: Omit<KxmGateObservationInput, "checkedCount" | "failedCount" | "elapsedMs" | "startedAt"> & {
       elapsedMs?: number;
       startedAt?: string;
     },
-  ): VnextGateObservationInput {
+  ): KxmGateObservationInput {
     const elapsedNs = process.hrtime.bigint() - this.startedMono;
     return {
       ...facts,
@@ -481,7 +481,7 @@ class CommandObserver implements VnextCommandObserver {
     };
   }
 
-  private handoffWith(outcome: VnextCommandOutcome): void {
+  private handoffWith(outcome: KxmCommandOutcome): void {
     if (this.handedOff) return;
     this.handedOff = true;
     this.canSignal = false;
@@ -491,7 +491,7 @@ class CommandObserver implements VnextCommandObserver {
     this.clearTimer("final");
     this.clearTimer("linger");
     this.child?.unref();
-    dropVnextCommandStopCapability(this);
+    dropKxmCommandStopCapability(this);
     this.resolveOutcome?.(outcome);
   }
 
@@ -502,11 +502,11 @@ class CommandObserver implements VnextCommandObserver {
   }
 }
 
-function dropVnextCommandStopCapability(observer: CommandObserver): void {
+function dropKxmCommandStopCapability(observer: CommandObserver): void {
   observer.requestStop = () => undefined;
 }
 
-function isCompleteNormal(observation: VnextGateObservationInput): boolean {
+function isCompleteNormal(observation: KxmGateObservationInput): boolean {
   return observation.completeness === "complete"
     && observation.spawned === 1
     && typeof observation.pid === "number"

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

@@ -1,7 +1,7 @@
-import type { JsonObject, JsonValue } from "./vnext-config.ts";
+import type { JsonObject, JsonValue } from "./project-config.ts";
 
-export const VNEXT_COMPILED_WORKFLOW_SCHEMA = "kxm.compiled-workflow.v1";
-export const VNEXT_RESERVED_STEP_KINDS = ["workflow"] as const;
+export const KXM_COMPILED_WORKFLOW_SCHEMA = "kxm.compiled-workflow.v1";
+export const KXM_RESERVED_STEP_KINDS = ["workflow"] as const;
 
 const WORKFLOW_SCHEMA = "kxm.workflow.v1";
 const STEP_ID_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/;
@@ -22,30 +22,30 @@ export type ReadonlyJsonValue =
   | { readonly [key: string]: ReadonlyJsonValue };
 export type ReadonlyJsonObject = { readonly [key: string]: ReadonlyJsonValue };
 
-export type VnextTerminalStatus = "completed" | "failed" | "cancelled";
-export type VnextCompiledStepKind = "agent" | "moa" | "gate" | "approval" | "wait";
-export type VnextRepositoryAccess = "none" | "read" | "write";
+export type KxmTerminalStatus = "completed" | "failed" | "cancelled";
+export type KxmCompiledStepKind = "agent" | "moa" | "gate" | "approval" | "wait";
+export type KxmRepositoryAccess = "none" | "read" | "write";
 
-export type VnextCompiledTransition =
+export type KxmCompiledTransition =
   | { readonly to: "step"; readonly target: string; readonly edge: "forward" | "back"; readonly maxTransitions?: number }
-  | { readonly to: "terminal"; readonly terminalStatus: VnextTerminalStatus; readonly maxTransitions?: number };
+  | { readonly to: "terminal"; readonly terminalStatus: KxmTerminalStatus; readonly maxTransitions?: number };
 
-export interface VnextCompiledProducerPolicy {
+export interface KxmCompiledProducerPolicy {
   readonly minimumProducers: number;
   readonly eligibleAgents: readonly string[];
   readonly acceptedStatuses: readonly ["passed"];
   readonly degradation?: { readonly minimumProducers: number };
 }
 
-export interface VnextCompiledEvidence {
+export interface KxmCompiledEvidence {
   readonly key: string;
   readonly kind: "assignment-result" | "gate" | "receipt" | "approval" | "artifact";
   readonly minimum: number;
   readonly reusableAcrossAttempts: boolean;
-  readonly producerPolicy?: VnextCompiledProducerPolicy;
+  readonly producerPolicy?: KxmCompiledProducerPolicy;
 }
 
-export interface VnextCompiledAssignments {
+export interface KxmCompiledAssignments {
   readonly allowedAgents: readonly string[]; // declared, else [step.agent] when present, else []
   readonly minimum: number;
   readonly target: number;
@@ -56,13 +56,13 @@ export interface VnextCompiledAssignments {
   readonly distinctBy: readonly ("provider" | "model" | "profile")[];
 }
 
-export interface VnextCompiledJoin {
+export interface KxmCompiledJoin {
   readonly strategy: "all" | "all-settled" | "quorum" | "first-success";
   readonly minimumPassed?: number;
   readonly cancelRemaining?: boolean;
 }
 
-interface VnextCompiledStepBase {
+interface KxmCompiledStepBase {
   readonly id: string;
   readonly index: number;
   readonly description?: string;
@@ -70,26 +70,26 @@ interface VnextCompiledStepBase {
   readonly maxAttempts: number;
   readonly timeoutMs?: number;
   readonly safeSpeculation: boolean;
-  readonly repositories: Readonly<Record<string, VnextRepositoryAccess>>;
+  readonly repositories: Readonly<Record<string, KxmRepositoryAccess>>;
   readonly tools?: ReadonlyJsonObject;
   readonly secrets: readonly ReadonlyJsonObject[];
   readonly model?: ReadonlyJsonValue;
-  readonly requiredEvidence: readonly VnextCompiledEvidence[];
+  readonly requiredEvidence: readonly KxmCompiledEvidence[];
   readonly outcomes: readonly string[];
-  readonly transitions: Readonly<Record<string, VnextCompiledTransition>>;
+  readonly transitions: Readonly<Record<string, KxmCompiledTransition>>;
   readonly requiresPlanHash: boolean;
-  readonly assignments: VnextCompiledAssignments;
-  readonly join: VnextCompiledJoin;
+  readonly assignments: KxmCompiledAssignments;
+  readonly join: KxmCompiledJoin;
 }
 
-export type VnextCompiledStep =
-  | (VnextCompiledStepBase & { readonly kind: "agent" | "moa"; readonly agent: string })
-  | (VnextCompiledStepBase & { readonly kind: "gate"; readonly gate: string; readonly expect: "pass" | "fail" })
-  | (VnextCompiledStepBase & { readonly kind: "approval" })
-  | (VnextCompiledStepBase & { readonly kind: "wait"; readonly signal: string });
+export type KxmCompiledStep =
+  | (KxmCompiledStepBase & { readonly kind: "agent" | "moa"; readonly agent: string })
+  | (KxmCompiledStepBase & { readonly kind: "gate"; readonly gate: string; readonly expect: "pass" | "fail" })
+  | (KxmCompiledStepBase & { readonly kind: "approval" })
+  | (KxmCompiledStepBase & { readonly kind: "wait"; readonly signal: string });
 
-export interface VnextCompiledPlan {
-  readonly schema: typeof VNEXT_COMPILED_WORKFLOW_SCHEMA;
+export interface KxmCompiledPlan {
+  readonly schema: typeof KXM_COMPILED_WORKFLOW_SCHEMA;
   readonly workflowId: string;
   readonly sourcePath?: string;
   readonly coordinator: string;
@@ -104,13 +104,13 @@ export interface VnextCompiledPlan {
   readonly hasBackEdges: boolean;
   readonly entryStepId: string;
   readonly order: readonly string[];
-  readonly steps: Readonly<Record<string, VnextCompiledStep>>;
+  readonly steps: Readonly<Record<string, KxmCompiledStep>>;
   readonly reproOracle?: { readonly stageId: string; readonly evidenceKey: string };
   readonly planHash?: { readonly stageId: string; readonly evidenceKey: string };
   readonly requirePlanHash: readonly string[];
 }
 
-export interface VnextEngineCompileIssue {
+export interface KxmEngineCompileIssue {
   readonly code: string;
   readonly workflowId: string;
   readonly stepId?: string;
@@ -118,18 +118,18 @@ export interface VnextEngineCompileIssue {
   readonly message: string;
 }
 
-export class VnextEngineCompileError extends Error {
-  readonly issues: readonly VnextEngineCompileIssue[];
+export class KxmEngineCompileError extends Error {
+  readonly issues: readonly KxmEngineCompileIssue[];
 
-  constructor(issues: readonly VnextEngineCompileIssue[]) {
+  constructor(issues: readonly KxmEngineCompileIssue[]) {
     const sorted = sortIssues(issues);
     super(sorted.map((issue) => `${issue.workflowId}: ${issue.code}: ${issue.message}`).join("\n"));
-    this.name = "VnextEngineCompileError";
+    this.name = "KxmEngineCompileError";
     this.issues = sorted;
   }
 }
 
-export interface VnextWorkflowCompileInput {
+export interface KxmWorkflowCompileInput {
   readonly id: string;
   readonly value: JsonObject;
   readonly logicalPath?: string;
@@ -137,10 +137,10 @@ export interface VnextWorkflowCompileInput {
 
 interface IssueSink {
   workflowId: string;
-  issues: VnextEngineCompileIssue[];
+  issues: KxmEngineCompileIssue[];
 }
 
-export function compileVnextWorkflow(input: VnextWorkflowCompileInput): VnextCompiledPlan {
+export function compileKxmWorkflow(input: KxmWorkflowCompileInput): KxmCompiledPlan {
   const sink: IssueSink = { workflowId: input.id, issues: [] };
   const value = input.value;
   if (value.schema !== WORKFLOW_SCHEMA) {
@@ -169,7 +169,7 @@ export function compileVnextWorkflow(input: VnextWorkflowCompileInput): VnextCom
   const limitsObject = objectValue(value.limits);
   const limits = compileLimits(limitsObject, sink);
   const requirePlanHash = names(value.requirePlanHash);
-  const compiledSteps: VnextCompiledStep[] = [];
+  const compiledSteps: KxmCompiledStep[] = [];
   let hasBackEdges = false;
 
   for (const [index, step] of rawSteps.entries()) {
@@ -193,17 +193,17 @@ export function compileVnextWorkflow(input: VnextWorkflowCompileInput): VnextCom
     }
   }
 
-  if (sink.issues.length > 0) throw new VnextEngineCompileError(sink.issues);
+  if (sink.issues.length > 0) throw new KxmEngineCompileError(sink.issues);
 
   const order = compiledSteps.map((step) => step.id);
-  const steps = Object.create(null) as Record<string, VnextCompiledStep>;
+  const steps = Object.create(null) as Record<string, KxmCompiledStep>;
   for (const step of compiledSteps) steps[step.id] = step;
   const entryStepId = order[0];
-  if (!entryStepId) throw new VnextEngineCompileError(sink.issues);
+  if (!entryStepId) throw new KxmEngineCompileError(sink.issues);
   const coordinator = stringValue(value.coordinator) ?? "coordinator";
   const transitionBudget = limits.maxTransitions ?? order.length;
-  const plan: VnextCompiledPlan = {
-    schema: VNEXT_COMPILED_WORKFLOW_SCHEMA,
+  const plan: KxmCompiledPlan = {
+    schema: KXM_COMPILED_WORKFLOW_SCHEMA,
     workflowId: input.id,
     ...(input.logicalPath !== undefined ? { sourcePath: input.logicalPath } : {}),
     coordinator,
@@ -223,7 +223,7 @@ export function compileVnextWorkflow(input: VnextWorkflowCompileInput): VnextCom
 function compileLimits(
   limits: JsonObject | undefined,
   sink: IssueSink,
-): VnextCompiledPlan["limits"] {
+): KxmCompiledPlan["limits"] {
   if (!limits) return {};
   const compiled: {
     maxTransitions?: number;
@@ -260,7 +260,7 @@ function compileStep(
   stepIndex: ReadonlyMap<string, number>,
   requirePlanHash: readonly string[],
   sink: IssueSink,
-): VnextCompiledStep | undefined {
+): KxmCompiledStep | undefined {
   const id = stringValue(step.id);
   if (!id || !isStepId(id) || stepIndex.get(id) !== index) return undefined;
   const kind = stringValue(step.kind);
@@ -299,7 +299,7 @@ function compileStep(
   const requiredEvidence = compileEvidence(step, id, sink);
   const transitions = compileTransitions(step, id, index, stepIndex, sink);
   const outcomes = Object.keys(transitions).sort(compareCodeUnits);
-  const orderedTransitions = Object.create(null) as Record<string, VnextCompiledTransition>;
+  const orderedTransitions = Object.create(null) as Record<string, KxmCompiledTransition>;
   for (const outcome of outcomes) {
     const transition = transitions[outcome];
     if (transition) orderedTransitions[outcome] = transition;
@@ -307,7 +307,7 @@ function compileStep(
 
   const description = stringValue(step.description);
   const instructions = stringValue(step.instructions);
-  const base: VnextCompiledStepBase = {
+  const base: KxmCompiledStepBase = {
     id,
     index,
     ...(description !== undefined ? { description } : {}),
@@ -347,11 +347,11 @@ function compileAssignments(
   stepId: string,
   primaryAgentId: string | undefined,
   sink: IssueSink,
-): VnextCompiledAssignments {
+): KxmCompiledAssignments {
   const assignment = objectValue(step.assignments);
   const declaredAgents = assignment ? names(assignment.allowedAgents) : [];
   const allowedAgents = declaredAgents.length > 0 ? declaredAgents : primaryAgentId ? [primaryAgentId] : [];
-  // Mirrors validateWorkflow in vnext-config.ts (minimum 1, target = minimum, maximum = target, maxParallel = maximum) for every kind. Do not resolve kind-conditional defaults here; the loader is the ceiling authority. Phase 7 changes both together.
+  // Mirrors validateWorkflow in project-config.ts (minimum 1, target = minimum, maximum = target, maxParallel = maximum) for every kind. Do not resolve kind-conditional defaults here; the loader is the ceiling authority. Phase 7 changes both together.
   const minimum = compileCountField(assignment?.minimum, 1, `${stepId}.assignments.minimum`, stepId, sink);
   const target = compileCountField(assignment?.target, minimum, `${stepId}.assignments.target`, stepId, sink);
   const maximum = compileCountField(assignment?.maximum, target, `${stepId}.assignments.maximum`, stepId, sink);
@@ -382,15 +382,15 @@ function compileAssignments(
   };
 }
 
-function compileJoin(step: JsonObject, stepId: string, sink: IssueSink): VnextCompiledJoin {
+function compileJoin(step: JsonObject, stepId: string, sink: IssueSink): KxmCompiledJoin {
   const join = objectValue(step.join);
   if (!join) return { strategy: "all" };
   const declared = stringValue(join.strategy);
   const strategy = declared && JOIN_STRATEGIES.has(declared)
-    ? declared as VnextCompiledJoin["strategy"]
+    ? declared as KxmCompiledJoin["strategy"]
     : "all";
   const minimumPassed = compileOptionalCount(join.minimumPassed, `${stepId}.join.minimumPassed`, stepId, sink);
-  const compiled: VnextCompiledJoin = {
+  const compiled: KxmCompiledJoin = {
     strategy,
     ...(minimumPassed !== undefined ? { minimumPassed } : {}),
     ...(typeof join.cancelRemaining === "boolean" ? { cancelRemaining: join.cancelRemaining } : {}),
@@ -398,8 +398,8 @@ function compileJoin(step: JsonObject, stepId: string, sink: IssueSink): VnextCo
   return compiled;
 }
 
-function compileEvidence(step: JsonObject, stepId: string, sink: IssueSink): VnextCompiledEvidence[] {
-  const evidence: VnextCompiledEvidence[] = [];
+function compileEvidence(step: JsonObject, stepId: string, sink: IssueSink): KxmCompiledEvidence[] {
+  const evidence: KxmCompiledEvidence[] = [];
   const seen = new Set<string>();
   for (const candidate of valuesOf(step, "requiredEvidence")) {
     const requirement = objectValue(candidate);
@@ -415,9 +415,9 @@ function compileEvidence(step: JsonObject, stepId: string, sink: IssueSink): Vne
     if (!kind || !EVIDENCE_KINDS.has(kind)) continue;
     const minimum = compileCountField(requirement.minimum, 1, `${stepId}.${key}.minimum`, stepId, sink);
     const producerPolicy = objectValue(requirement.producerPolicy);
-    const compiled: VnextCompiledEvidence = {
+    const compiled: KxmCompiledEvidence = {
       key,
-      kind: kind as VnextCompiledEvidence["kind"],
+      kind: kind as KxmCompiledEvidence["kind"],
       minimum,
       reusableAcrossAttempts: requirement.reusableAcrossAttempts === true,
       ...(producerPolicy ? { producerPolicy: compileProducerPolicy(producerPolicy, stepId, key, sink) } : {}),
@@ -432,7 +432,7 @@ function compileProducerPolicy(
   stepId: string,
   key: string,
   sink: IssueSink,
-): VnextCompiledProducerPolicy {
+): KxmCompiledProducerPolicy {
   const minimumProducers = compileCountField(
     policy.minimumProducers,
     1,
@@ -461,9 +461,9 @@ function compileTransitions(
   index: number,
   stepIndex: ReadonlyMap<string, number>,
   sink: IssueSink,
-): Record<string, VnextCompiledTransition> {
+): Record<string, KxmCompiledTransition> {
   const outcomes = objectValue(step.on);
-  const compiled = Object.create(null) as Record<string, VnextCompiledTransition>;
+  const compiled = Object.create(null) as Record<string, KxmCompiledTransition>;
   if (!outcomes || Object.keys(outcomes).length === 0) {
     pushIssue(sink, { code: "transitions_missing", stepId, message: `${stepId} has no declared transitions` });
     return compiled;
@@ -499,7 +499,7 @@ function compileTransitions(
       }
       compiled[outcome] = {
         to: "terminal",
-        terminalStatus: status as VnextTerminalStatus,
+        terminalStatus: status as KxmTerminalStatus,
         ...(maxTransitions !== undefined ? { maxTransitions } : {}),
       };
       continue;
@@ -557,7 +557,7 @@ function parseTransition(value: JsonValue): { target?: string; maxTransitions?:
 function compileOracle(
   field: "reproOracle" | "planHash",
   oracle: JsonObject | undefined,
-  steps: readonly VnextCompiledStep[],
+  steps: readonly KxmCompiledStep[],
   sink: IssueSink,
 ): { stageId: string; evidenceKey: string } | undefined {
   if (!oracle) return undefined;
@@ -578,12 +578,12 @@ function compileOracle(
   return { stageId, evidenceKey };
 }
 
-function compileRepositories(value: JsonValue | undefined): Readonly<Record<string, VnextRepositoryAccess>> {
+function compileRepositories(value: JsonValue | undefined): Readonly<Record<string, KxmRepositoryAccess>> {
   const source = objectValue(value) ?? {};
-  const repositories: Record<string, VnextRepositoryAccess> = {};
+  const repositories: Record<string, KxmRepositoryAccess> = {};
   for (const [id, access] of Object.entries(source)) {
     if (typeof access === "string" && REPOSITORY_ACCESS.has(access)) {
-      repositories[id] = access as VnextRepositoryAccess;
+      repositories[id] = access as KxmRepositoryAccess;
     }
   }
   return repositories;
@@ -707,7 +707,7 @@ function compareOptional(left: string | undefined, right: string | undefined): n
   return compareCodeUnits(left, right);
 }
 
-function sortIssues(issues: readonly VnextEngineCompileIssue[]): VnextEngineCompileIssue[] {
+function sortIssues(issues: readonly KxmEngineCompileIssue[]): KxmEngineCompileIssue[] {
   return [...issues].sort((left, right) => {
     const byStep = compareOptional(left.stepId, right.stepId);
     if (byStep !== 0) return byStep;
@@ -717,6 +717,6 @@ function sortIssues(issues: readonly VnextEngineCompileIssue[]): VnextEngineComp
   });
 }
 
-function pushIssue(sink: IssueSink, issue: Omit<VnextEngineCompileIssue, "workflowId">): void {
+function pushIssue(sink: IssueSink, issue: Omit<KxmEngineCompileIssue, "workflowId">): void {
   sink.issues.push({ workflowId: sink.workflowId, ...issue });
 }