@kontextmind/kxm 0.7.40 → 0.7.43

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

@@ -1,22 +1,22 @@
-import type { VnextCompiledPlan, VnextCompiledStep, VnextCompiledTransition, VnextTerminalStatus } from "./vnext-engine-compile.ts";
+import type { KxmCompiledPlan, KxmCompiledStep, KxmCompiledTransition, KxmTerminalStatus } from "./engine-compile.ts";
 import {
   runtimeError,
-  type VnextRunEvent,
-  type VnextRunRecord,
-  type VnextRunStatus,
-} from "./vnext-runtime-store.ts";
+  type KxmRunEvent,
+  type KxmRunRecord,
+  type KxmRunStatus,
+} from "./runtime-store.ts";
 
-export const VNEXT_RUN_STATE_SCHEMA = "kxm.run-state.v2";
+export const KXM_RUN_STATE_SCHEMA = "kxm.run-state.v2";
 export const FOLD_PANEL_BOUND = 1;
 
-const RUN_STATUSES = new Set<VnextRunStatus>(["created", "preparing", "running", "waiting", "blocked_uncertain", "cancelling", "cancelled", "completed", "failed"]);
-const TERMINAL_RUN = new Set<VnextRunStatus>(["cancelled", "completed", "failed"]);
+const RUN_STATUSES = new Set<KxmRunStatus>(["created", "preparing", "running", "waiting", "blocked_uncertain", "cancelling", "cancelled", "completed", "failed"]);
+const TERMINAL_RUN = new Set<KxmRunStatus>(["cancelled", "completed", "failed"]);
 const STEP_STATUSES = new Set(["pending", "preparing", "running", "passed", "failed", "cancelled"]);
 const ASSIGNMENT_STATUSES = new Set(["created", "accepted", "dispatched", "executing", "result_recorded", "terminal"]);
 const ATTEMPT_STATUSES = new Set(["created", "starting", "executing", "settling", "terminal"]);
 const RESULT_CLASSES = new Set(["outcome", "outcome_unknown", "producer_rejected", "cancelled"]);
-const SLICE_BLOCKED_RUN = new Set<VnextRunStatus>(["waiting"]);
-const RUN_EDGES: Readonly<Record<string, ReadonlySet<VnextRunStatus>>> = {
+const SLICE_BLOCKED_RUN = new Set<KxmRunStatus>(["waiting"]);
+const RUN_EDGES: Readonly<Record<string, ReadonlySet<KxmRunStatus>>> = {
   created: new Set(["preparing", "cancelled", "failed"]),
   preparing: new Set(["running", "cancelled", "failed"]),
   running: new Set(["blocked_uncertain", "cancelling", "cancelled", "completed", "failed"]),
@@ -46,7 +46,7 @@ const ATTEMPT_EDGES: Readonly<Record<string, ReadonlySet<string>>> = {
   settling: new Set(["terminal"]),
 };
 
-export type VnextRunEffectState =
+export type KxmRunEffectState =
   | "intent"
   | "dispatched"
   | "observed-complete"
@@ -56,7 +56,7 @@ export type VnextRunEffectState =
   | "settled"
   | "settled-proof";
 
-export interface VnextFoldOptions {
+export interface KxmFoldOptions {
   readonly observationLookup?: (
     attemptId: string,
     observationId: string,
@@ -67,17 +67,17 @@ export interface VnextFoldOptions {
   };
 }
 
-export type VnextRunDurationBudgetSource = "workflow" | "project" | "both";
+export type KxmRunDurationBudgetSource = "workflow" | "project" | "both";
 
-export interface VnextRunDurationBudget {
+export interface KxmRunDurationBudget {
   readonly budgetMs: number;
-  readonly source: VnextRunDurationBudgetSource;
+  readonly source: KxmRunDurationBudgetSource;
 }
 
 export function effectiveRunDurationBudget(
   planLimits: { readonly maxRunDurationMs?: number } | undefined,
   projectLimits: { readonly maxRunDurationMs?: number } | undefined,
-): VnextRunDurationBudget | undefined {
+): KxmRunDurationBudget | undefined {
   const workflow = planLimits?.maxRunDurationMs;
   const project = projectLimits?.maxRunDurationMs;
   if (workflow === undefined && project === undefined) return undefined;
@@ -88,42 +88,42 @@ export function effectiveRunDurationBudget(
   return { budgetMs: project!, source: "project" };
 }
 
-export interface VnextFoldAttemptState {
+export interface KxmFoldAttemptState {
   readonly status: string;
   readonly resultClass?: string | undefined;
   readonly outcome?: string | undefined;
 }
 
-export interface VnextFoldAssignmentState {
+export interface KxmFoldAssignmentState {
   readonly status: string;
   readonly currentAttemptId?: string | undefined;
-  readonly attempts: Readonly<Record<string, VnextFoldAttemptState>>;
+  readonly attempts: Readonly<Record<string, KxmFoldAttemptState>>;
 }
 
-export interface VnextFoldPanel {
+export interface KxmFoldPanel {
   readonly order: readonly string[];
-  readonly assignments: Readonly<Record<string, VnextFoldAssignmentState>>;
+  readonly assignments: Readonly<Record<string, KxmFoldAssignmentState>>;
 }
 
-export type VnextJoinAllResult =
+export type KxmJoinAllResult =
   | { readonly tag: "unsatisfied" }
   | { readonly tag: "outcome"; readonly outcome: string }
   | { readonly tag: "conflict" }
   | { readonly tag: "rejected" }
   | { readonly tag: "cancelled" };
 
-export interface VnextRunCurrentStep {
+export interface KxmRunCurrentStep {
   readonly stepId: string;
   readonly stepAttempt: number;
   readonly status: string;
-  readonly panel: VnextFoldPanel;
+  readonly panel: KxmFoldPanel;
   readonly assignmentId?: string | undefined;
   readonly attemptId?: string | undefined;
   readonly assignmentStatus?: string | undefined;
   readonly attemptStatus?: string | undefined;
   readonly outcome?: string | undefined;
   readonly effectId?: string | undefined;
-  readonly effectState?: VnextRunEffectState | undefined;
+  readonly effectState?: KxmRunEffectState | undefined;
   readonly observationId?: string | undefined;
   readonly observationHash?: string | undefined;
   readonly observationCompleteness?: "complete" | "no-start" | "unknown" | undefined;
@@ -131,26 +131,26 @@ export interface VnextRunCurrentStep {
   readonly evidenceRefs?: readonly { id: string; kind: string; hash: string; status: string }[] | undefined;
 }
 
-export interface VnextRunDriveBinding {
+export interface KxmRunDriveBinding {
   readonly driveId: string;
   readonly mode: "simulated" | "live";
   readonly openedSequence: number;
 }
 
-export interface VnextRunState {
-  readonly schema: typeof VNEXT_RUN_STATE_SCHEMA;
+export interface KxmRunState {
+  readonly schema: typeof KXM_RUN_STATE_SCHEMA;
   readonly runId: string;
-  readonly status: VnextRunStatus;
+  readonly status: KxmRunStatus;
   readonly runPlanHash?: string | undefined;
   readonly pendingStepId?: string | undefined;
-  readonly currentStep?: VnextRunCurrentStep | undefined;
+  readonly currentStep?: KxmRunCurrentStep | undefined;
   readonly stepAttempts: Readonly<Record<string, number>>;
   readonly edgeTransitions: Readonly<Record<string, number>>;
   readonly transitionsUsed: number;
   readonly cancelRequested: boolean;
   readonly terminalReason?: string | undefined;
   readonly failureReason?: string | undefined;
-  readonly drive?: VnextRunDriveBinding | undefined;
+  readonly drive?: KxmRunDriveBinding | undefined;
   readonly runningSince?: string | undefined;
 }
 
@@ -178,7 +178,7 @@ interface MutableCurrentStep {
   panel: MutablePanel;
   outcome?: string | undefined;
   effectId?: string | undefined;
-  effectState?: VnextRunEffectState | undefined;
+  effectState?: KxmRunEffectState | undefined;
   observationId?: string | undefined;
   observationHash?: string | undefined;
   observationCompleteness?: "complete" | "no-start" | "unknown" | undefined;
@@ -187,9 +187,9 @@ interface MutableCurrentStep {
 }
 
 interface MutableState {
-  schema: typeof VNEXT_RUN_STATE_SCHEMA;
+  schema: typeof KXM_RUN_STATE_SCHEMA;
   runId: string;
-  status: VnextRunStatus;
+  status: KxmRunStatus;
   runPlanHash?: string | undefined;
   pendingStepId?: string | undefined;
   currentStep?: MutableCurrentStep | undefined;
@@ -202,8 +202,8 @@ interface MutableState {
   lastOutcomeEvent?: { stepId: string; stepAttempt: number; outcome: string } | undefined;
   awaitingTransition: boolean;
   cancelCommandId?: string | undefined;
-  lastTerminalTransition?: VnextTerminalStatus | undefined;
-  drive?: VnextRunDriveBinding | undefined;
+  lastTerminalTransition?: KxmTerminalStatus | undefined;
+  drive?: KxmRunDriveBinding | undefined;
   runningSince?: string | undefined;
 }
 
@@ -230,10 +230,10 @@ function panelAttempt(current: MutableCurrentStep): MutableAttempt | undefined {
   return attemptId ? assignment.attempts[attemptId] : undefined;
 }
 
-export function vnextFoldPanelAttempt(
-  step: VnextRunCurrentStep | MutableCurrentStep | undefined,
+export function kxmFoldPanelAttempt(
+  step: KxmRunCurrentStep | MutableCurrentStep | undefined,
   attemptId: string,
-): { assignmentId: string; assignment: MutableAssignment | VnextFoldAssignmentState; attempt: MutableAttempt | VnextFoldAttemptState } | undefined {
+): { assignmentId: string; assignment: MutableAssignment | KxmFoldAssignmentState; attempt: MutableAttempt | KxmFoldAttemptState } | undefined {
   if (!step) return undefined;
   for (const assignmentId of step.panel.order) {
     const assignment = step.panel.assignments[assignmentId];
@@ -255,7 +255,7 @@ function findPanelAttempt(
   return undefined;
 }
 
-function panelAssignmentBound(plan: VnextCompiledPlan | undefined, current: MutableCurrentStep): number {
+function panelAssignmentBound(plan: KxmCompiledPlan | undefined, current: MutableCurrentStep): number {
   const step = plan?.steps[current.stepId];
   if (!step) return FOLD_PANEL_BOUND;
   if ((step.kind === "agent" || step.kind === "moa") && (step.join.strategy === "all" || step.join.strategy === "all-settled")) {
@@ -303,7 +303,7 @@ function panelFrozen(current: MutableCurrentStep): boolean {
     || current.status === "cancelled";
 }
 
-function createdOnlySingletonCancel(state: MutableState, step: VnextCompiledStep, current: MutableCurrentStep, status: string): boolean {
+function createdOnlySingletonCancel(state: MutableState, step: KxmCompiledStep, current: MutableCurrentStep, status: string): boolean {
   const assignmentId = current.panel.order[0];
   const assignment = assignmentId ? current.panel.assignments[assignmentId] : undefined;
   return status === "cancelled"
@@ -313,7 +313,7 @@ function createdOnlySingletonCancel(state: MutableState, step: VnextCompiledStep
     && assignment?.status === "created";
 }
 
-function authorizedCancelStep(state: MutableState, step: VnextCompiledStep, current: MutableCurrentStep, status: string): boolean {
+function authorizedCancelStep(state: MutableState, step: KxmCompiledStep, current: MutableCurrentStep, status: string): boolean {
   if (status !== "cancelled" || !state.cancelRequested) return false;
   if (createdOnlySingletonCancel(state, step, current, status)) return true;
   if (!panelIssuedAttemptsTerminal(current) || !panelAssignmentsTerminal(current)) return false;
@@ -349,14 +349,14 @@ function currentAttemptOf(assignment: {
   return attemptId ? assignment.attempts[attemptId] : undefined;
 }
 
-function expectedStatusForDeclaredOutcome(step: VnextCompiledStep, outcome: string): "passed" | "failed" | "cancelled" {
+function expectedStatusForDeclaredOutcome(step: KxmCompiledStep, outcome: string): "passed" | "failed" | "cancelled" {
   // Classify by outcome name only, never terminal target
   if (outcome === "passed") return "passed";
   if (outcome === "cancelled") return "cancelled";
   return "failed";
 }
 
-export function vnextJoinAll(step: VnextCompiledStep, panel: VnextFoldPanel | MutablePanel): VnextJoinAllResult {
+export function kxmJoinAll(step: KxmCompiledStep, panel: KxmFoldPanel | MutablePanel): KxmJoinAllResult {
   if (panel.order.length < step.assignments.minimum) return { tag: "unsatisfied" };
   const members: Array<{ resultClass: string; outcome?: string | undefined }> = [];
   for (const assignmentId of panel.order) {
@@ -414,7 +414,7 @@ function putAssignment(current: MutableCurrentStep, assignmentId: string, assign
   };
 }
 
-export function vnextFoldPanelAttemptIds(step: VnextRunCurrentStep | MutableCurrentStep | undefined): string[] {
+export function kxmFoldPanelAttemptIds(step: KxmRunCurrentStep | MutableCurrentStep | undefined): string[] {
   if (!step) return [];
   const ids: string[] = [];
   for (const assignmentId of step.panel.order) {
@@ -425,17 +425,17 @@ export function vnextFoldPanelAttemptIds(step: VnextRunCurrentStep | MutableCurr
   return ids;
 }
 
-export function foldVnextRunState(
-  run: VnextRunRecord,
-  plan: VnextCompiledPlan | undefined,
-  events: readonly VnextRunEvent[],
-  options: VnextFoldOptions = {},
-): VnextRunState {
+export function foldKxmRunState(
+  run: KxmRunRecord,
+  plan: KxmCompiledPlan | undefined,
+  events: readonly KxmRunEvent[],
+  options: KxmFoldOptions = {},
+): KxmRunState {
   if (events.length === 0) {
     throw runtimeError("run_events_illegal", run.runId, "run has no events");
   }
   const state: MutableState = {
-    schema: VNEXT_RUN_STATE_SCHEMA,
+    schema: KXM_RUN_STATE_SCHEMA,
     runId: run.runId,
     status: "created",
     stepAttempts: Object.create(null) as Record<string, number>,
@@ -563,7 +563,7 @@ export function foldVnextRunState(
   return freezeState(state);
 }
 
-function assertEventIdentity(run: VnextRunRecord, event: VnextRunEvent): void {
+function assertEventIdentity(run: KxmRunRecord, event: KxmRunEvent): void {
   if (event.schema !== "kxm.run-event.v1") {
     throw runtimeError("run_events_illegal", run.runId, "event schema is not kxm.run-event.v1");
   }
@@ -580,7 +580,7 @@ function assertEventIdentity(run: VnextRunRecord, event: VnextRunEvent): void {
   }
 }
 
-function foldRunCreated(state: MutableState, run: VnextRunRecord, event: VnextRunEvent, index: number): void {
+function foldRunCreated(state: MutableState, run: KxmRunRecord, event: KxmRunEvent, index: number): void {
   if (index !== 0 || event.sequence !== 1) {
     throw runtimeError("run_events_illegal", state.runId, "run.created is only legal at sequence 1");
   }
@@ -593,12 +593,12 @@ function foldRunCreated(state: MutableState, run: VnextRunRecord, event: VnextRu
   state.status = "created";
 }
 
-function foldRunStatus(state: MutableState, plan: VnextCompiledPlan | undefined, event: VnextRunEvent): void {
+function foldRunStatus(state: MutableState, plan: KxmCompiledPlan | undefined, event: KxmRunEvent): void {
   const next = event.payload.status;
-  if (typeof next !== "string" || !RUN_STATUSES.has(next as VnextRunStatus)) {
+  if (typeof next !== "string" || !RUN_STATUSES.has(next as KxmRunStatus)) {
     throw runtimeError("run_events_illegal", state.runId, `run.status_changed has invalid status ${String(next)}`);
   }
-  const status = next as VnextRunStatus;
+  const status = next as KxmRunStatus;
   if (SLICE_BLOCKED_RUN.has(status)) {
     throw runtimeError("run_events_illegal", state.runId, `event type ${event.eventType} is not legal in this engine slice`);
   }
@@ -649,9 +649,9 @@ function foldRunStatus(state: MutableState, plan: VnextCompiledPlan | undefined,
 
 function assertTerminalRunStatus(
   state: MutableState,
-  plan: VnextCompiledPlan | undefined,
-  status: VnextRunStatus,
-  event: VnextRunEvent,
+  plan: KxmCompiledPlan | undefined,
+  status: KxmRunStatus,
+  event: KxmRunEvent,
 ): void {
   if (status === "completed") {
     if (state.lastTerminalTransition !== "completed") {
@@ -699,7 +699,7 @@ function assertTerminalRunStatus(
   }
 }
 
-function isProvenFailure(state: MutableState, plan: VnextCompiledPlan | undefined): boolean {
+function isProvenFailure(state: MutableState, plan: KxmCompiledPlan | undefined): boolean {
   const current = state.currentStep;
   if (current) {
     const stepTerminal = current.status === "passed" || current.status === "failed" || current.status === "cancelled";
@@ -707,7 +707,7 @@ function isProvenFailure(state: MutableState, plan: VnextCompiledPlan | undefine
     if (stepTerminal && settled) {
       const step = plan?.steps[current.stepId];
       if (step && current.status === "failed") {
-        const joined = vnextJoinAll(step, current.panel);
+        const joined = kxmJoinAll(step, current.panel);
         if (joined.tag === "rejected" || joined.tag === "conflict") return true;
       }
       if (plan && current.outcome) {
@@ -734,7 +734,7 @@ function isProvenFailure(state: MutableState, plan: VnextCompiledPlan | undefine
   return Boolean(step && used >= step.maxAttempts);
 }
 
-function foldDriveOpened(state: MutableState, event: VnextRunEvent): void {
+function foldDriveOpened(state: MutableState, event: KxmRunEvent): void {
   if (state.status !== "running" && state.status !== "blocked_uncertain") {
     throw runtimeError("run_events_illegal", state.runId, "run.drive_opened is only legal while running or blocked_uncertain");
   }
@@ -748,9 +748,9 @@ function foldDriveOpened(state: MutableState, event: VnextRunEvent): void {
 
 function foldCancelRequested(
   state: MutableState,
-  event: VnextRunEvent,
-  plan: VnextCompiledPlan | undefined,
-  options: VnextFoldOptions,
+  event: KxmRunEvent,
+  plan: KxmCompiledPlan | undefined,
+  options: KxmFoldOptions,
 ): void {
   if (state.cancelRequested || TERMINAL_RUN.has(state.status)) {
     throw runtimeError("run_events_illegal", state.runId, "duplicate run.cancel_requested is not legal");
@@ -791,7 +791,7 @@ function requireRunning(state: MutableState, eventType: string): void {
   }
 }
 
-function foldStepEntered(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldStepEntered(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   if (state.status !== "running") {
     throw runtimeError("run_events_illegal", state.runId, "step.entered is only legal while running");
   }
@@ -819,7 +819,7 @@ function foldStepEntered(state: MutableState, plan: VnextCompiledPlan, event: Vn
   state.currentStep = { stepId, stepAttempt, status: "pending", panel: emptyPanel() };
 }
 
-function foldStepStatus(state: MutableState, plan: VnextCompiledPlan | undefined, event: VnextRunEvent): void {
+function foldStepStatus(state: MutableState, plan: KxmCompiledPlan | undefined, event: KxmRunEvent): void {
   requireActiveStep(state, "step.status_changed");
   const stepId = stringPayload(event, "stepId");
   const status = stringPayload(event, "status");
@@ -840,7 +840,7 @@ function foldStepStatus(state: MutableState, plan: VnextCompiledPlan | undefined
     }
     const step = plan ? requireStep(plan, current.stepId, state.runId) : undefined;
     if (step) {
-      const joined = vnextJoinAll(step, current.panel);
+      const joined = kxmJoinAll(step, current.panel);
       if (joined.tag === "outcome") {
         const expectedStatus = expectedStatusForDeclaredOutcome(step, joined.outcome);
         const selected = step.transitions[joined.outcome];
@@ -891,7 +891,7 @@ function foldStepStatus(state: MutableState, plan: VnextCompiledPlan | undefined
   state.currentStep = { ...state.currentStep!, status };
 }
 
-function foldOutcome(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldOutcome(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   requireActiveStep(state, "step.outcome_recorded");
   const stepId = stringPayload(event, "stepId");
   const stepAttempt = integerPayload(event, "stepAttempt");
@@ -907,7 +907,7 @@ function foldOutcome(state: MutableState, plan: VnextCompiledPlan, event: VnextR
     throw runtimeError("run_events_illegal", state.runId, "step.outcome_recorded cannot overwrite a recorded outcome");
   }
   const step = requireStep(plan, stepId, state.runId);
-  const joined = vnextJoinAll(step, current.panel);
+  const joined = kxmJoinAll(step, current.panel);
   if (joined.tag !== "outcome" || joined.outcome !== outcome) {
     throw runtimeError("run_events_illegal", state.runId, "step.outcome_recorded does not match the recorded assignment outcome");
   }
@@ -918,7 +918,7 @@ function foldOutcome(state: MutableState, plan: VnextCompiledPlan, event: VnextR
   state.lastOutcomeEvent = { stepId, stepAttempt, outcome };
 }
 
-function foldTransitioned(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldTransitioned(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   requireActiveStep(state, "step.transitioned");
   const fromStepId = stringPayload(event, "fromStepId");
   const outcome = stringPayload(event, "outcome");
@@ -936,7 +936,7 @@ function foldTransitioned(state: MutableState, plan: VnextCompiledPlan, event: V
     throw runtimeError("run_events_illegal", state.runId, "step.transitioned requires every panel assignment and issued attempt to be terminal");
   }
   const step = requireStep(plan, fromStepId, state.runId);
-  const joined = vnextJoinAll(step, current.panel);
+  const joined = kxmJoinAll(step, current.panel);
   if (joined.tag !== "outcome" || joined.outcome !== outcome) {
     throw runtimeError("run_events_illegal", state.runId, "step.transitioned requires a matching joined declared outcome");
   }
@@ -971,7 +971,7 @@ function foldTransitioned(state: MutableState, plan: VnextCompiledPlan, event: V
   state.lastOutcomeEvent = undefined;
 }
 
-function assertTransitionPayload(runId: string, selected: VnextCompiledTransition, event: VnextRunEvent): void {
+function assertTransitionPayload(runId: string, selected: KxmCompiledTransition, event: KxmRunEvent): void {
   if (selected.to === "step") {
     if (event.payload.toStepId !== selected.target) {
       throw runtimeError("run_events_illegal", runId, "step.transitioned toStepId does not match the compiled target");
@@ -989,7 +989,7 @@ function assertTransitionPayload(runId: string, selected: VnextCompiledTransitio
   }
 }
 
-function foldAssignmentCreated(state: MutableState, plan: VnextCompiledPlan | undefined, event: VnextRunEvent): void {
+function foldAssignmentCreated(state: MutableState, plan: KxmCompiledPlan | undefined, event: KxmRunEvent): void {
   requireActiveStep(state, "assignment.created");
   const current = state.currentStep!;
   if (state.status !== "running" || state.cancelRequested || panelFrozen(current)) {
@@ -1019,7 +1019,7 @@ function foldAssignmentCreated(state: MutableState, plan: VnextCompiledPlan | un
   };
 }
 
-function foldAssignmentAdvance(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent, next: string): void {
+function foldAssignmentAdvance(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent, next: string): void {
   requireActiveStep(state, `assignment.${next}`);
   const current = state.currentStep!;
   if (current.panel.order.length === 0) {
@@ -1131,7 +1131,7 @@ function foldAssignmentAdvance(state: MutableState, plan: VnextCompiledPlan, eve
   state.currentStep = putAssignment(current, assignmentId, nextAssignment);
 }
 
-function foldAttemptCreated(state: MutableState, event: VnextRunEvent): void {
+function foldAttemptCreated(state: MutableState, event: KxmRunEvent): void {
   requireActiveStep(state, "attempt.created");
   const current = state.currentStep!;
   if (state.status !== "running" || state.cancelRequested || panelFrozen(current)) {
@@ -1156,10 +1156,10 @@ function foldAttemptCreated(state: MutableState, event: VnextRunEvent): void {
   });
 }
 
-function foldAttemptStatus(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldAttemptStatus(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   requireActiveStep(state, "attempt.status_changed");
   const current = state.currentStep!;
-  if (vnextFoldPanelAttemptIds(current).length === 0) {
+  if (kxmFoldPanelAttemptIds(current).length === 0) {
     throw runtimeError("run_events_illegal", state.runId, "attempt.status_changed has no active attempt");
   }
   const attemptId = stringPayload(event, "attemptId");
@@ -1198,7 +1198,7 @@ function foldAttemptStatus(state: MutableState, plan: VnextCompiledPlan, event:
   });
 }
 
-function requireGateEffect(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): NonNullable<MutableState["currentStep"]> {
+function requireGateEffect(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): NonNullable<MutableState["currentStep"]> {
   requireActiveStep(state, event.eventType);
   const current = state.currentStep!;
   const step = requireStep(plan, current.stepId, state.runId);
@@ -1209,7 +1209,7 @@ function requireGateEffect(state: MutableState, plan: VnextCompiledPlan, event:
   return current;
 }
 
-function assertEffectIdentity(state: MutableState, event: VnextRunEvent, current: NonNullable<MutableState["currentStep"]>): void {
+function assertEffectIdentity(state: MutableState, event: KxmRunEvent, current: NonNullable<MutableState["currentStep"]>): void {
   const effect = event.payload.effect;
   if (!effect || typeof effect !== "object" || Array.isArray(effect)) {
     throw runtimeError("run_events_illegal", state.runId, `${event.eventType} is missing effect`);
@@ -1230,7 +1230,7 @@ function assertEffectIdentity(state: MutableState, event: VnextRunEvent, current
   }
 }
 
-function foldEffectIntent(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldEffectIntent(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   const current = requireGateEffect(state, plan, event);
   if (panelAttempt(current)?.status !== "starting" || current.effectState) {
     throw runtimeError("run_events_illegal", state.runId, "effect.intent_recorded requires a starting attempt with no effect");
@@ -1239,7 +1239,7 @@ function foldEffectIntent(state: MutableState, plan: VnextCompiledPlan, event: V
   state.currentStep = { ...current, effectId, effectState: "intent" };
 }
 
-function foldEffectDispatched(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldEffectDispatched(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   const current = requireGateEffect(state, plan, event);
   if (current.effectState !== "intent") {
     throw runtimeError("run_events_illegal", state.runId, "effect.dispatched requires effect intent");
@@ -1250,7 +1250,7 @@ function foldEffectDispatched(state: MutableState, plan: VnextCompiledPlan, even
   state.currentStep = { ...current, effectState: "dispatched" };
 }
 
-function foldEffectObserved(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent, options: VnextFoldOptions): void {
+function foldEffectObserved(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent, options: KxmFoldOptions): void {
   const current = requireGateEffect(state, plan, event);
   if (current.effectState === "observed-complete" || current.effectState === "observed-no-start" || current.effectState === "observed-unknown") {
     throw runtimeError("run_events_illegal", state.runId, "a completed observation cannot be rewritten");
@@ -1277,7 +1277,7 @@ function foldEffectObserved(state: MutableState, plan: VnextCompiledPlan, event:
     throw runtimeError("run_events_illegal", state.runId, "effect.observed receipt.kind does not match the pinned definition");
   }
   const looked = options.observationLookup?.(panelAttemptId(current)!, receiptId);
-  let effectState: VnextRunEffectState = "observed-unknown";
+  let effectState: KxmRunEffectState = "observed-unknown";
   if (looked) {
     if (looked.completeness === "complete") {
       if (current.effectState === "intent" && expectedKind !== "artifacts-exist") {
@@ -1302,7 +1302,7 @@ function foldEffectObserved(state: MutableState, plan: VnextCompiledPlan, event:
   };
 }
 
-function foldEffectSettled(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldEffectSettled(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   const current = requireGateEffect(state, plan, event);
   const hasOutcome = event.payload.outcome !== undefined;
   const hasEvidence = event.payload.evidenceRefs !== undefined;
@@ -1349,7 +1349,7 @@ function foldEffectSettled(state: MutableState, plan: VnextCompiledPlan, event:
   state.currentStep = { ...current, effectState: "settled-proof" };
 }
 
-function foldEffectUncertain(state: MutableState, plan: VnextCompiledPlan, event: VnextRunEvent): void {
+function foldEffectUncertain(state: MutableState, plan: KxmCompiledPlan, event: KxmRunEvent): void {
   const current = requireGateEffect(state, plan, event);
   if (current.effectState === "observed-complete" || current.effectState === "observed-no-start" || current.effectState === "observed-unknown") {
     throw runtimeError("run_events_illegal", state.runId, "blocked_uncertain after an observation is illegal");
@@ -1380,13 +1380,13 @@ function requireActiveStep(state: MutableState, eventType: string): void {
   }
 }
 
-function requireStep(plan: VnextCompiledPlan, stepId: string, runId: string): VnextCompiledStep {
+function requireStep(plan: KxmCompiledPlan, stepId: string, runId: string): KxmCompiledStep {
   const step = plan.steps[stepId];
   if (!step) throw runtimeError("run_events_illegal", runId, `unknown step ${stepId}`);
   return step;
 }
 
-function stringPayload(event: VnextRunEvent, field: string): string {
+function stringPayload(event: KxmRunEvent, field: string): string {
   const value = event.payload[field];
   if (typeof value !== "string" || value.length === 0) {
     throw runtimeError("run_events_illegal", event.runId, `${event.eventType} is missing ${field}`);
@@ -1394,7 +1394,7 @@ function stringPayload(event: VnextRunEvent, field: string): string {
   return value;
 }
 
-function integerPayload(event: VnextRunEvent, field: string): number {
+function integerPayload(event: KxmRunEvent, field: string): number {
   const value = event.payload[field];
   if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
     throw runtimeError("run_events_illegal", event.runId, `${event.eventType} is missing a valid ${field}`);
@@ -1402,11 +1402,11 @@ function integerPayload(event: VnextRunEvent, field: string): number {
   return value;
 }
 
-function freezePanel(panel: MutablePanel): VnextFoldPanel {
-  const assignments: Record<string, VnextFoldAssignmentState> = Object.create(null);
+function freezePanel(panel: MutablePanel): KxmFoldPanel {
+  const assignments: Record<string, KxmFoldAssignmentState> = Object.create(null);
   for (const assignmentId of Object.keys(panel.assignments).sort()) {
     const assignment = panel.assignments[assignmentId]!;
-    const attempts: Record<string, VnextFoldAttemptState> = Object.create(null);
+    const attempts: Record<string, KxmFoldAttemptState> = Object.create(null);
     for (const attemptId of Object.keys(assignment.attempts).sort()) {
       attempts[attemptId] = Object.freeze(omitUndefined({ ...assignment.attempts[attemptId]! }));
     }
@@ -1422,7 +1422,7 @@ function freezePanel(panel: MutablePanel): VnextFoldPanel {
   });
 }
 
-function freezeCurrentStep(current: MutableCurrentStep): VnextRunCurrentStep {
+function freezeCurrentStep(current: MutableCurrentStep): KxmRunCurrentStep {
   const panel = freezePanel(current.panel);
   const assignmentId = panel.order.length === 1 ? panel.order[0] : undefined;
   const assignment = assignmentId ? panel.assignments[assignmentId] : undefined;
@@ -1448,9 +1448,9 @@ function freezeCurrentStep(current: MutableCurrentStep): VnextRunCurrentStep {
   }));
 }
 
-function freezeState(state: MutableState): VnextRunState {
-  const frozen: VnextRunState = {
-    schema: VNEXT_RUN_STATE_SCHEMA,
+function freezeState(state: MutableState): KxmRunState {
+  const frozen: KxmRunState = {
+    schema: KXM_RUN_STATE_SCHEMA,
     runId: state.runId,
     status: state.status,
     ...(state.runPlanHash !== undefined ? { runPlanHash: state.runPlanHash } : {}),
@@ -1476,10 +1476,10 @@ function omitUndefined<T extends Record<string, unknown>>(value: T): T {
   return copy;
 }
 
-export function isTerminalRunStatus(status: VnextRunStatus): boolean {
+export function isTerminalRunStatus(status: KxmRunStatus): boolean {
   return TERMINAL_RUN.has(status);
 }
 
-export function isVnextTerminalStatus(value: string): value is VnextTerminalStatus {
+export function isKxmTerminalStatus(value: string): value is KxmTerminalStatus {
   return value === "completed" || value === "failed" || value === "cancelled";
 }