@kontextmind/kxm 0.7.40 → 0.7.44

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

@@ -11,85 +11,85 @@ import {
   type FormalContextPacketV2,
   type HandoffManifestV1,
 } from "./context-packet.ts";
-import { compileVnextWorkflow, type VnextCompiledPlan, type VnextCompiledStep } from "./vnext-engine-compile.ts";
+import { compileKxmWorkflow, type KxmCompiledPlan, type KxmCompiledStep } from "./engine-compile.ts";
 import {
   effectiveRunDurationBudget,
   isTerminalRunStatus,
-  vnextFoldPanelAttempt,
-  vnextFoldPanelAttemptIds,
-  vnextJoinAll,
-  type VnextRunDurationBudget,
-  type VnextRunState,
-} from "./vnext-engine-fold.ts";
+  kxmFoldPanelAttempt,
+  kxmFoldPanelAttemptIds,
+  kxmJoinAll,
+  type KxmRunDurationBudget,
+  type KxmRunState,
+} from "./engine-fold.ts";
 import {
-  VNEXT_RUN_PLAN_SCHEMA,
-  freezeVnextCompiledPlan,
-  hashVnextRunPlanEnvelope,
-  loadVnextRunPlanEnvelope,
+  KXM_RUN_PLAN_SCHEMA,
+  freezeKxmCompiledPlan,
+  hashKxmRunPlanEnvelope,
+  loadKxmRunPlanEnvelope,
   parseGateDefinition,
-  rehydrateVnextCompiledPlanFromStore,
-  type VnextPinnedGates,
-  type VnextRunPlanEnvelope,
-} from "./vnext-engine-plan.ts";
-import { gateRegistryHash } from "./vnext-gate-hash.ts";
+  rehydrateKxmCompiledPlanFromStore,
+  type KxmPinnedGates,
+  type KxmRunPlanEnvelope,
+} from "./engine-plan.ts";
+import { gateRegistryHash } from "./gate-hash.ts";
 import {
-  admitVnextRun,
-  armVnextGateHold,
-  attachVnextDriveSession,
-  bindVnextSchedulerPolicy,
-  clearVnextDriveSession,
-  dropVnextGateStopHook,
-  enqueueVnextScheduledRun,
-  finishVnextOwnedGate,
-  markVnextGateHoldUnsettled,
-  registerVnextAttemptController,
-  releaseVnextRun,
-  resolveVnextGateHold,
-  unregisterVnextAttemptController,
-  vnextAdmittedToken,
-  vnextAttemptController,
-  vnextAttemptControllers,
-  vnextGateHold,
-  vnextSchedulerPolicy,
-  type VnextDriveSession,
-} from "./vnext-runtime-owner.ts";
+  admitKxmRun,
+  armKxmGateHold,
+  attachKxmDriveSession,
+  bindKxmSchedulerPolicy,
+  clearKxmDriveSession,
+  dropKxmGateStopHook,
+  enqueueKxmScheduledRun,
+  finishKxmOwnedGate,
+  markKxmGateHoldUnsettled,
+  registerKxmAttemptController,
+  releaseKxmRun,
+  resolveKxmGateHold,
+  unregisterKxmAttemptController,
+  kxmAdmittedToken,
+  kxmAttemptController,
+  kxmAttemptControllers,
+  kxmGateHold,
+  kxmSchedulerPolicy,
+  type KxmDriveSession,
+} from "./runtime-owner.ts";
 import {
-  cancelVnextRun,
-  foldStoredVnextRun,
-  isVnextRuntimeContextClosed,
-  persistVnextRunState,
-  registerVnextRuntimeCloseHook,
-  vnextEventBase,
-  vnextIncrementMonotonicNs,
-  vnextMonotonicNs,
-  vnextPolicyRevisions,
-  vnextProjectAdmissionLimits,
-  type VnextMemoryRevisionOptions,
-  type VnextRuntimeContext,
-} from "./vnext-runtime.ts";
+  cancelKxmRun,
+  foldStoredKxmRun,
+  isKxmRuntimeContextClosed,
+  persistKxmRunState,
+  registerKxmRuntimeCloseHook,
+  kxmEventBase,
+  kxmIncrementMonotonicNs,
+  kxmMonotonicNs,
+  kxmPolicyRevisions,
+  kxmProjectAdmissionLimits,
+  type KxmMemoryRevisionOptions,
+  type KxmRuntimeContext,
+} from "./runtime-service.ts";
 import {
-  hashVnextDriveLog,
-  newVnextAssignmentId,
-  newVnextAttemptId,
-  newVnextEventId,
+  hashKxmDriveLog,
+  newKxmAssignmentId,
+  newKxmAttemptId,
+  newKxmEventId,
   projectRuntimeKey,
   runtimeError,
-  verifyVnextDriveReceipt,
-  VNEXT_DRIVE_RECEIPT_SCHEMA,
-  type VnextAttemptCapabilityRow,
-  type VnextDriveReceipt,
-  type VnextDriveReceiptBudget,
-  type VnextDriveReceiptHandoff,
-  type VnextGateAttemptRow,
-  type VnextGateEvidenceRow,
-  type VnextGateObservationRow,
-  type VnextRunEvent,
-  type VnextRunRecord,
-  type VnextRunStatus,
-} from "./vnext-runtime-store.ts";
-import { VnextConfigError, vnextCanonicalJson, type JsonValue, type VnextProjectBundle } from "./vnext-config.ts";
-import { evaluateArtifactsGate } from "./vnext-engine-artifacts.ts";
-import { createCommandObserver } from "./vnext-engine-command.ts";
+  verifyKxmDriveReceipt,
+  KXM_DRIVE_RECEIPT_SCHEMA,
+  type KxmAttemptCapabilityRow,
+  type KxmDriveReceipt,
+  type KxmDriveReceiptBudget,
+  type KxmDriveReceiptHandoff,
+  type KxmGateAttemptRow,
+  type KxmGateEvidenceRow,
+  type KxmGateObservationRow,
+  type KxmRunEvent,
+  type KxmRunRecord,
+  type KxmRunStatus,
+} from "./runtime-store.ts";
+import { KxmConfigError, kxmCanonicalJson, type JsonValue, type KxmProjectBundle } from "./project-config.ts";
+import { evaluateArtifactsGate } from "./engine-artifacts.ts";
+import { createCommandObserver } from "./engine-command.ts";
 import {
   recordGateCancelObservedInTransaction,
   recordGateIntentInTransaction,
@@ -97,8 +97,8 @@ import {
   recordGateSettlementInTransaction,
   recordGateSpawnedInTransaction,
   recordGateUncertainInTransaction,
-  type VnextGateObservationInput,
-} from "./vnext-engine-gate-records.ts";
+  type KxmGateObservationInput,
+} from "./engine-gate-records.ts";
 import {
   ROUTING_RECORD_V2_SCHEMA,
   type RoutingRecordV2,
@@ -124,7 +124,7 @@ export {
 const trustedProducers = new WeakSet<object>();
 const CAPABILITY_PREFIX = "kxm-attempt-capability\0";
 
-export interface VnextProducerRequest {
+export interface KxmProducerRequest {
   readonly runId: string;
   readonly stepId: string;
   readonly stepAttempt: number;
@@ -146,7 +146,7 @@ export interface VnextProducerRequest {
   readonly handoffManifest?: HandoffManifestV1 | undefined;
 }
 
-export interface VnextProducerResult {
+export interface KxmProducerResult {
   readonly outcome: string;
   /** Host cannot attest termination; retain the issued attempt, never replay or settle it. */
   readonly effectUncertain?: true;
@@ -169,13 +169,13 @@ export interface VnextProducerResult {
   readonly providerMetadata?: Record<string, string | number | boolean>;
 }
 
-export interface VnextProducer {
+export interface KxmProducer {
   readonly id: "driver-simulated" | "pi" | "oneshot";
-  produce(request: VnextProducerRequest): Promise<VnextProducerResult>;
+  produce(request: KxmProducerRequest): Promise<KxmProducerResult>;
   close?(): Promise<void>;
 }
 
-export interface VnextRunHandoff {
+export interface KxmRunHandoff {
   readonly reason: "limit_unsupported" | "step_unsupported" | "attempt_unreconciled" | "cancel_pending_foreign" | "gate_unsupported" | "gate_outcome_undeclared" | "gate_recovery_pending" | "attempt_unsettled" | "gate_uncertain_blocked";
   readonly field?: string;
   readonly stepId?: string;
@@ -183,22 +183,22 @@ export interface VnextRunHandoff {
   readonly detail: string;
 }
 
-export interface VnextRunDriveResult {
-  readonly state: VnextRunState;
-  readonly handoff?: VnextRunHandoff;
+export interface KxmRunDriveResult {
+  readonly state: KxmRunState;
+  readonly handoff?: KxmRunHandoff;
 }
 
-export interface VnextAttemptCapabilityRecord extends VnextAttemptCapabilityRow {
+export interface KxmAttemptCapabilityRecord extends KxmAttemptCapabilityRow {
   readonly runPlanHash: string;
   readonly toolPolicyRevision: string;
 }
 
-export function createVnextSimulatedProducer(
-  script: (request: VnextProducerRequest) => Promise<VnextProducerResult> | VnextProducerResult,
-): VnextProducer {
+export function createKxmSimulatedProducer(
+  script: (request: KxmProducerRequest) => Promise<KxmProducerResult> | KxmProducerResult,
+): KxmProducer {
   const producer = Object.freeze({
     id: "driver-simulated" as const,
-    async produce(request: VnextProducerRequest): Promise<VnextProducerResult> {
+    async produce(request: KxmProducerRequest): Promise<KxmProducerResult> {
       const start = Date.now();
       try {
         const raw = await script(request);
@@ -221,11 +221,11 @@ export function createVnextSimulatedProducer(
   return producer;
 }
 
-export function registerTrustedProducer(producer: VnextProducer): void {
+export function registerTrustedProducer(producer: KxmProducer): void {
   trustedProducers.add(producer);
 }
 
-function requireTrustedProducer(producer: VnextProducer): void {
+function requireTrustedProducer(producer: KxmProducer): void {
   if (!trustedProducers.has(producer)) {
     throw runtimeError("engine_producer_untrusted", "producer", "producer is not a trusted factory instance");
   }
@@ -235,21 +235,21 @@ function hashCapabilitySecret(secret: string): string {
   return `sha256:${createHash("sha256").update(`${CAPABILITY_PREFIX}${secret}`, "utf8").digest("hex")}`;
 }
 
-export function mintVnextCapabilitySecret(): { secret: string; hash: string } {
+export function mintKxmCapabilitySecret(): { secret: string; hash: string } {
   const secret = `kxmcap_${randomBytes(32).toString("base64url")}`;
   return { secret, hash: hashCapabilitySecret(secret) };
 }
 
 function mintCapabilitySecret(): { secret: string; hash: string } {
-  return mintVnextCapabilitySecret();
+  return mintKxmCapabilitySecret();
 }
 
-export function pinVnextCompiledPlan(
-  context: VnextRuntimeContext,
-  bundle: VnextProjectBundle,
+export function pinKxmCompiledPlan(
+  context: KxmRuntimeContext,
+  bundle: KxmProjectBundle,
   runId: string,
-  options?: VnextMemoryRevisionOptions,
-): { plan: VnextCompiledPlan; runPlanHash: string; idempotent: boolean; event?: VnextRunEvent } {
+  options?: KxmMemoryRevisionOptions,
+): { plan: KxmCompiledPlan; runPlanHash: string; idempotent: boolean; event?: KxmRunEvent } {
   return context.eventStore.transaction(() => {
     const run = requireRun(context, runId);
     if (run.projectId !== context.projectId || run.homeRuntimeId !== context.homeRuntimeId) {
@@ -260,7 +260,7 @@ export function pinVnextCompiledPlan(
     }
     const workflow = bundle.workflows.get(run.workflowId);
     if (!workflow) throw runtimeError("run_workflow_unknown", run.workflowId, `workflow ${run.workflowId} does not exist in this project`);
-    const revisions = vnextPolicyRevisions(bundle, options);
+    const revisions = kxmPolicyRevisions(bundle, options);
     if (
       revisions.configRevision !== run.configRevision
       || revisions.executorPolicyRevision !== run.executorPolicyRevision
@@ -269,13 +269,13 @@ export function pinVnextCompiledPlan(
     ) {
       throw runtimeError("run_revision_drift", runId, "bundle revisions do not match the accepted run");
     }
-    const compiled = freezeVnextCompiledPlan(compileVnextWorkflow({
+    const compiled = freezeKxmCompiledPlan(compileKxmWorkflow({
       id: run.workflowId,
       value: workflow.value,
       ...(workflow.logicalPath !== undefined ? { logicalPath: workflow.logicalPath } : {}),
     }));
-    const envelope: VnextRunPlanEnvelope = {
-      schema: VNEXT_RUN_PLAN_SCHEMA,
+    const envelope: KxmRunPlanEnvelope = {
+      schema: KXM_RUN_PLAN_SCHEMA,
       runId: run.runId,
       projectId: run.projectId,
       homeRuntimeId: run.homeRuntimeId,
@@ -286,11 +286,11 @@ export function pinVnextCompiledPlan(
         toolPolicy: run.toolPolicyRevision,
         memory: run.memoryRevision,
       },
-      projectLimits: vnextProjectAdmissionLimits(bundle),
+      projectLimits: kxmProjectAdmissionLimits(bundle),
       plan: compiled,
       gates: pinnedGatesForCompiledPlan(compiled, bundle, context.projectRoot),
     };
-    const runPlanHash = hashVnextRunPlanEnvelope(envelope);
+    const runPlanHash = hashKxmRunPlanEnvelope(envelope);
     const existing = context.eventStore.runPlan(runId);
     if (existing) {
       if (existing.runPlanHash !== runPlanHash) {
@@ -303,9 +303,9 @@ export function pinVnextCompiledPlan(
     }
     const now = new Date().toISOString();
     const sequence = context.eventStore.nextSequence(runId);
-    const event: VnextRunEvent = {
-      ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-      eventId: newVnextEventId(),
+    const event: KxmRunEvent = {
+      ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+      eventId: newKxmEventId(),
       eventType: "run.status_changed",
       sequence,
       payload: { status: "preparing", runPlanHash },
@@ -313,28 +313,28 @@ export function pinVnextCompiledPlan(
     context.eventStore.insertRunPlan({
       runId,
       runPlanHash,
-      envelope: vnextCanonicalJson(envelope as unknown as JsonValue),
+      envelope: kxmCanonicalJson(envelope as unknown as JsonValue),
       pinnedSequence: sequence,
     });
     context.eventStore.appendEvent(event);
-    const state = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, runId, state, sequence);
+    const state = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, runId, state, sequence);
     context.eventStore.updateRunStatus(runId, "preparing", now);
     return { plan: compiled, runPlanHash, idempotent: false, event };
   });
 }
 
-export function rehydrateVnextCompiledPlan(context: VnextRuntimeContext, runId: string): VnextCompiledPlan {
+export function rehydrateKxmCompiledPlan(context: KxmRuntimeContext, runId: string): KxmCompiledPlan {
   const run = requireRun(context, runId);
-  return rehydrateVnextCompiledPlanFromStore(context.eventStore, run);
+  return rehydrateKxmCompiledPlanFromStore(context.eventStore, run);
 }
 
-export function startVnextRun(context: VnextRuntimeContext, runId: string, options: { allowLimits?: boolean } = {}): VnextRunDriveResult {
+export function startKxmRun(context: KxmRuntimeContext, runId: string, options: { allowLimits?: boolean } = {}): KxmRunDriveResult {
   return context.eventStore.transaction(() => {
     const run = requireRun(context, runId);
-    const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
+    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
     const unsupported = options.allowLimits ? undefined : unsupportedLimit(envelope);
-    const state = foldStoredVnextRun(context, run);
+    const state = foldStoredKxmRun(context, run);
     if (unsupported) {
       return { state, handoff: unsupported };
     }
@@ -343,32 +343,32 @@ export function startVnextRun(context: VnextRuntimeContext, runId: string, optio
     }
     const now = new Date().toISOString();
     const sequence = context.eventStore.nextSequence(runId);
-    const event: VnextRunEvent = {
-      ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-      eventId: newVnextEventId(),
+    const event: KxmRunEvent = {
+      ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+      eventId: newKxmEventId(),
       eventType: "run.status_changed",
       sequence,
       payload: { status: "running" },
     };
     context.eventStore.appendEvent(event);
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, runId, next, sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, runId, next, sequence);
     context.eventStore.updateRunStatus(runId, "running", now);
     return { state: next };
   });
 }
 
-export async function stepVnextRun(context: VnextRuntimeContext, runId: string, producer: VnextProducer): Promise<VnextRunDriveResult> {
+export async function stepKxmRun(context: KxmRuntimeContext, runId: string, producer: KxmProducer): Promise<KxmRunDriveResult> {
   requireTrustedProducer(producer);
   return withAdmission(context, runId, (token) => stepLocked(context, runId, producer, token));
 }
 
-export async function driveVnextRun(
-  context: VnextRuntimeContext,
+export async function driveKxmRun(
+  context: KxmRuntimeContext,
   runId: string,
-  producer: VnextProducer,
+  producer: KxmProducer,
   options: { allowLimits?: boolean; liveMode?: boolean } = {},
-): Promise<VnextRunDriveResult> {
+): Promise<KxmRunDriveResult> {
   requireTrustedProducer(producer);
   const run = requireRun(context, runId);
   if (run.status === "created") {
@@ -378,18 +378,18 @@ export async function driveVnextRun(
 }
 
 async function driveAdmitted(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   runId: string,
-  producer: VnextProducer,
+  producer: KxmProducer,
   token: string,
   options: { allowLimits?: boolean; liveMode?: boolean } = {},
-): Promise<VnextRunDriveResult> {
+): Promise<KxmRunDriveResult> {
   const run = requireRun(context, runId);
   if (run.status === "preparing") {
-    const started = startVnextRun(context, runId, options);
+    const started = startKxmRun(context, runId, options);
     if (started.handoff || isTerminalRunStatus(started.state.status)) return started;
   }
-  let latest: VnextRunDriveResult = { state: foldStoredVnextRun(context, requireRun(context, runId)) };
+  let latest: KxmRunDriveResult = { state: foldStoredKxmRun(context, requireRun(context, runId)) };
   while (latest.state.status === "running") {
     const overBudget = cancelRunDurationIfExceeded(context, runId);
     if (overBudget) return overBudget;
@@ -406,19 +406,19 @@ async function driveAdmitted(
   return latest;
 }
 
-async function withAdmission<T>(context: VnextRuntimeContext, runId: string, fn: (token: string) => Promise<T>): Promise<T> {
+async function withAdmission<T>(context: KxmRuntimeContext, runId: string, fn: (token: string) => Promise<T>): Promise<T> {
   const token = admitPinnedRun(context, runId);
   try {
     return await fn(token);
   } finally {
-    releaseVnextRun(context.eventStore.path, runId, token);
+    releaseKxmRun(context.eventStore.path, runId, token);
   }
 }
 
-function admitPinnedRun(context: VnextRuntimeContext, runId: string): string {
+function admitPinnedRun(context: KxmRuntimeContext, runId: string): string {
   const run = requireRun(context, runId);
-  const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
-  return admitVnextRun(
+  const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
+  return admitKxmRun(
     context.eventStore.path,
     runId,
     envelope.revisions.config,
@@ -426,47 +426,47 @@ function admitPinnedRun(context: VnextRuntimeContext, runId: string): string {
   );
 }
 
-export interface OpenVnextDriveSessionOptions {
+export interface OpenKxmDriveSessionOptions {
   mode: "simulated" | "live";
   allowLimits?: boolean;
   liveMode?: boolean;
-  createProducer: () => VnextProducer;
+  createProducer: () => KxmProducer;
 }
 
-export interface VnextDriveSessionHandle {
+export interface KxmDriveSessionHandle {
   driveId: string;
-  settled: Promise<VnextRunDriveResult>;
+  settled: Promise<KxmRunDriveResult>;
 }
 
 function newDriveId(runId: string, token: string, runtimeId: string, monotonicNs: string): string {
   return `drv_${createHash("sha256").update(`${runId}\0${token}\0${runtimeId}\0${monotonicNs}`, "utf8").digest("hex").slice(0, 24)}`;
 }
 
-export interface VnextDrivePollProjection {
+export interface KxmDrivePollProjection {
   driveId: string;
   mode: "simulated" | "live";
   openedAt: string;
-  receipt: VnextDriveReceipt | null;
+  receipt: KxmDriveReceipt | null;
   verified: boolean;
   divergence?: string;
 }
 
-export interface VnextDriveReceiptCloseInfo {
+export interface KxmDriveReceiptCloseInfo {
   kind: "terminal" | "handoff" | "unsettled";
   reason?: string;
-  handoff?: VnextRunHandoff;
+  handoff?: KxmRunHandoff;
   error?: { class: string; component: string; retryable: boolean };
   producerId: string;
   producerClosed: boolean;
 }
 
 function driveErrorSummary(error: unknown): { class: string; component: string; retryable: boolean } {
-  const raw = error instanceof VnextConfigError ? error.issues[0]?.code : undefined;
+  const raw = error instanceof KxmConfigError ? error.issues[0]?.code : undefined;
   const className = raw && /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/.test(raw) ? raw : "drive-failure";
-  return { class: className, component: "vnext-engine", retryable: false };
+  return { class: className, component: "engine", retryable: false };
 }
 
-function receiptHandoff(handoff: VnextRunHandoff): VnextDriveReceiptHandoff {
+function receiptHandoff(handoff: KxmRunHandoff): KxmDriveReceiptHandoff {
   return {
     reason: handoff.reason,
     detail: handoff.detail,
@@ -476,7 +476,7 @@ function receiptHandoff(handoff: VnextRunHandoff): VnextDriveReceiptHandoff {
 }
 
 function appendDriveOpened(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   runId: string,
   driveId: string,
   mode: "simulated" | "live",
@@ -485,30 +485,30 @@ function appendDriveOpened(
     const run = requireRun(context, runId);
     const now = new Date().toISOString();
     const sequence = context.eventStore.nextSequence(runId);
-    const event: VnextRunEvent = {
-      ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-      eventId: newVnextEventId(),
+    const event: KxmRunEvent = {
+      ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+      eventId: newKxmEventId(),
       eventType: "run.drive_opened",
       sequence,
       payload: { driveId, mode },
     };
     context.eventStore.appendEvent(event);
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, runId, next, sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, runId, next, sequence);
     return { sequence, occurredAt: now };
   });
 }
 
 export function recordDriveReceipt(
-  context: VnextRuntimeContext,
-  session: VnextDriveSession,
-  closeInfo: VnextDriveReceiptCloseInfo,
+  context: KxmRuntimeContext,
+  session: KxmDriveSession,
+  closeInfo: KxmDriveReceiptCloseInfo,
 ): void {
-  if (isVnextRuntimeContextClosed(context)) return;
+  if (isKxmRuntimeContextClosed(context)) return;
   try {
     const run = context.eventStore.run(session.runId);
     if (!run) return;
-    const state = foldStoredVnextRun(context, run);
+    const state = foldStoredKxmRun(context, run);
     const events = context.eventStore.events(session.runId, 0, 1_000_000);
     if (events.length === 0) return;
     const opened = state.drive;
@@ -519,8 +519,8 @@ export function recordDriveReceipt(
     const openedSequence = opened?.openedSequence ?? openedEvent?.sequence;
     if (openedSequence === undefined) return;
     const closedAt = new Date().toISOString();
-    const receipt: VnextDriveReceipt = {
-      schema: VNEXT_DRIVE_RECEIPT_SCHEMA,
+    const receipt: KxmDriveReceipt = {
+      schema: KXM_DRIVE_RECEIPT_SCHEMA,
       driveId: session.driveId,
       runId: session.runId,
       projectId: run.projectId,
@@ -530,7 +530,7 @@ export function recordDriveReceipt(
       openedSequence,
       closedAt,
       lastSequence: last.sequence,
-      logHash: hashVnextDriveLog(events.filter((event) => event.sequence >= 1 && event.sequence <= last.sequence)),
+      logHash: hashKxmDriveLog(events.filter((event) => event.sequence >= 1 && event.sequence <= last.sequence)),
       settlement: {
         kind: closeInfo.kind,
         status: state.status,
@@ -547,22 +547,22 @@ export function recordDriveReceipt(
   }
 }
 
-export function vnextDrivePollProjection(
-  context: VnextRuntimeContext,
+export function kxmDrivePollProjection(
+  context: KxmRuntimeContext,
   runId: string,
-  state: VnextRunState,
-): VnextDrivePollProjection | undefined {
+  state: KxmRunState,
+): KxmDrivePollProjection | undefined {
   if (!state.drive) return undefined;
   const events = context.eventStore.events(runId, 0, 1_000_000);
   const openedEvent = events.find((event) => event.sequence === state.drive!.openedSequence);
-  let receipt: VnextDriveReceipt | null = null;
+  let receipt: KxmDriveReceipt | null = null;
   let unreadable = false;
   try {
     receipt = context.eventStore.driveReceipt(state.drive.driveId) ?? null;
   } catch {
     unreadable = true;
   }
-  const projection: VnextDrivePollProjection = {
+  const projection: KxmDrivePollProjection = {
     driveId: state.drive.driveId,
     mode: state.drive.mode,
     openedAt: openedEvent?.occurredAt ?? "",
@@ -577,7 +577,7 @@ export function vnextDrivePollProjection(
     projection.divergence = "no receipt";
     return projection;
   }
-  const checked = verifyVnextDriveReceipt(receipt, events, state.status, {
+  const checked = verifyKxmDriveReceipt(receipt, events, state.status, {
     runId,
     driveId: state.drive.driveId,
   });
@@ -586,50 +586,50 @@ export function vnextDrivePollProjection(
   return projection;
 }
 
-function inflightAttemptId(state: VnextRunState): string | undefined {
+function inflightAttemptId(state: KxmRunState): string | undefined {
   const leftover = unreconciledPanelAttemptId(state);
   if (leftover) return leftover;
   if (state.currentStep?.attemptId) {
-    const located = vnextFoldPanelAttempt(state.currentStep, state.currentStep.attemptId);
+    const located = kxmFoldPanelAttempt(state.currentStep, state.currentStep.attemptId);
     const status = located?.attempt.status;
     if (status === "starting" || status === "executing" || status === "settling") return state.currentStep.attemptId;
   }
   return undefined;
 }
 
-function recordExecutingUnrecordedFailure(context: VnextRuntimeContext, runId: string, attemptId: string, stepId: string): void {
+function recordExecutingUnrecordedFailure(context: KxmRuntimeContext, runId: string, attemptId: string, stepId: string): void {
   context.eventStore.transaction(() => {
     const run = requireRun(context, runId);
     const now = new Date().toISOString();
     const sequence = context.eventStore.nextSequence(runId);
-    const event: VnextRunEvent = {
-      ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-      eventId: newVnextEventId(),
+    const event: KxmRunEvent = {
+      ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+      eventId: newKxmEventId(),
       eventType: "run.status_changed",
       sequence,
       payload: { status: "failed", reason: "executing_unrecorded", stepId },
     };
     context.eventStore.appendEvent(event);
     context.eventStore.settleCapability(attemptId, "revoked");
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, runId, next, sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, runId, next, sequence);
     context.eventStore.updateRunStatus(runId, "failed", now);
   });
 }
 
-function recordBareDriveFailure(context: VnextRuntimeContext, runId: string): void {
-  if (isVnextRuntimeContextClosed(context)) return;
+function recordBareDriveFailure(context: KxmRuntimeContext, runId: string): void {
+  if (isKxmRuntimeContextClosed(context)) return;
   try {
     const run = context.eventStore.run(runId);
     if (!run) return;
-    const state = foldStoredVnextRun(context, run);
+    const state = foldStoredKxmRun(context, run);
     if (isTerminalRunStatus(state.status) || state.status === "cancelling") return;
     const inflight = inflightAttemptId(state);
     if (inflight) {
       const currentStep = state.currentStep;
-      const located = vnextFoldPanelAttempt(currentStep, inflight);
+      const located = kxmFoldPanelAttempt(currentStep, inflight);
       if (currentStep && currentStep.panel.order.length === 1 && located?.attempt.status === "starting") {
-        const plan = rehydrateVnextCompiledPlanFromStore(context.eventStore, run);
+        const plan = rehydrateKxmCompiledPlanFromStore(context.eventStore, run);
         const step = plan.steps[currentStep.stepId];
         if (step?.kind === "gate") return;
         if (step && (step.kind === "agent" || step.kind === "moa") && step.assignments.maximum > 1) return;
@@ -637,13 +637,13 @@ function recordBareDriveFailure(context: VnextRuntimeContext, runId: string): vo
       }
       return;
     }
-    cancelVnextRun(context, runId, { reason: "drive_error" });
+    cancelKxmRun(context, runId, { reason: "drive_error" });
   } catch {
     // The original drive error governs; this is a best-effort bare-running brake.
   }
 }
 
-async function closeDriveProducer(producer: VnextProducer): Promise<void> {
+async function closeDriveProducer(producer: KxmProducer): Promise<void> {
   if (typeof producer.close !== "function") return;
   try {
     await producer.close();
@@ -652,53 +652,53 @@ async function closeDriveProducer(producer: VnextProducer): Promise<void> {
   }
 }
 
-export class VnextRunScheduler {
-  private readonly context: VnextRuntimeContext;
-  private readonly bundle: VnextProjectBundle;
+export class KxmRunScheduler {
+  private readonly context: KxmRuntimeContext;
+  private readonly bundle: KxmProjectBundle;
   private readonly configRevision: string;
 
-  private constructor(context: VnextRuntimeContext, bundle: VnextProjectBundle) {
+  private constructor(context: KxmRuntimeContext, bundle: KxmProjectBundle) {
     this.context = context;
     this.bundle = bundle;
     this.configRevision = bundle.configRevision;
   }
 
-  static for(context: VnextRuntimeContext, bundle: VnextProjectBundle): VnextRunScheduler {
+  static for(context: KxmRuntimeContext, bundle: KxmProjectBundle): KxmRunScheduler {
     if (String(bundle.project.value.id) !== context.projectId) {
       throw runtimeError("run_owner_mismatch", context.projectId, "scheduler bundle project does not match the runtime context");
     }
-    const limits = vnextProjectAdmissionLimits(bundle);
-    bindVnextSchedulerPolicy(context.eventStore.path, limits.maxConcurrentRuns, bundle.configRevision);
-    return new VnextRunScheduler(context, bundle);
+    const limits = kxmProjectAdmissionLimits(bundle);
+    bindKxmSchedulerPolicy(context.eventStore.path, limits.maxConcurrentRuns, bundle.configRevision);
+    return new KxmRunScheduler(context, bundle);
   }
 
   enqueue(
     runId: string,
-    producer: VnextProducer,
+    producer: KxmProducer,
     options: { allowLimits?: boolean; liveMode?: boolean } = {},
-  ): Promise<VnextRunDriveResult> {
+  ): Promise<KxmRunDriveResult> {
     requireTrustedProducer(producer);
-    const policy = vnextSchedulerPolicy(this.context.eventStore.path);
+    const policy = kxmSchedulerPolicy(this.context.eventStore.path);
     if (!policy || policy.configRevision !== this.configRevision) {
       return Promise.reject(runtimeError("scheduler_policy_conflict", runId, "scheduler handle does not match the active policy"));
     }
     try {
       const run = requireRun(this.context, runId);
-      const envelope = loadVnextRunPlanEnvelope(this.context.eventStore, run);
-      return enqueueVnextScheduledRun(
+      const envelope = loadKxmRunPlanEnvelope(this.context.eventStore, run);
+      return enqueueKxmScheduledRun(
         this.context.eventStore.path,
         runId,
         envelope.revisions.config,
         envelope.projectLimits.maxConcurrentRuns,
         (token) => driveAdmitted(this.context, runId, producer, token, options),
-      ) as Promise<VnextRunDriveResult>;
+      ) as Promise<KxmRunDriveResult>;
     } catch (error) {
       return Promise.reject(error);
     }
   }
 
-  openDriveSession(runId: string, options: OpenVnextDriveSessionOptions): Promise<VnextDriveSessionHandle> {
-    const policy = vnextSchedulerPolicy(this.context.eventStore.path);
+  openDriveSession(runId: string, options: OpenKxmDriveSessionOptions): Promise<KxmDriveSessionHandle> {
+    const policy = kxmSchedulerPolicy(this.context.eventStore.path);
     if (!policy || policy.configRevision !== this.configRevision) {
       return Promise.reject(runtimeError("scheduler_policy_conflict", runId, "scheduler handle does not match the active policy"));
     }
@@ -711,48 +711,48 @@ export class VnextRunScheduler {
       return Promise.reject(error);
     }
 
-    const limits = vnextProjectAdmissionLimits(this.bundle);
+    const limits = kxmProjectAdmissionLimits(this.bundle);
     const driveOptions: { allowLimits?: boolean; liveMode?: boolean } = {
       liveMode: options.liveMode ?? options.mode === "live",
     };
     if (options.allowLimits !== undefined) driveOptions.allowLimits = options.allowLimits;
     let opened = false;
     const pending = {
-      resolve: (_value: VnextRunDriveResult) => undefined as void,
+      resolve: (_value: KxmRunDriveResult) => undefined as void,
       reject: (_error: unknown) => undefined as void,
     };
-    const settled = new Promise<VnextRunDriveResult>((resolve, reject) => {
+    const settled = new Promise<KxmRunDriveResult>((resolve, reject) => {
       pending.resolve = resolve;
       pending.reject = reject;
     });
     void settled.then(undefined, () => undefined);
 
-    return new Promise<VnextDriveSessionHandle>((resolveOpen, rejectOpen) => {
-      const queued = enqueueVnextScheduledRun(
+    return new Promise<KxmDriveSessionHandle>((resolveOpen, rejectOpen) => {
+      const queued = enqueueKxmScheduledRun(
         this.context.eventStore.path,
         runId,
         this.configRevision,
         limits.maxConcurrentRuns,
         async (token) => {
-          let producer: VnextProducer | undefined;
+          let producer: KxmProducer | undefined;
           try {
             producer = options.createProducer();
             requireTrustedProducer(producer);
             const current = requireRun(this.context, runId);
             if (current.status === "created") {
-              pinVnextCompiledPlan(this.context, this.bundle, runId);
+              pinKxmCompiledPlan(this.context, this.bundle, runId);
             }
-            const started = startVnextRun(this.context, runId, driveOptions);
+            const started = startKxmRun(this.context, runId, driveOptions);
             if (started.handoff) {
               const error = runtimeError("run_handoff_required", runId, started.handoff.detail);
               Object.assign(error, { handoff: started.handoff });
               throw error;
             }
-            const driveId = newDriveId(runId, token, this.context.homeRuntimeId, vnextMonotonicNs());
+            const driveId = newDriveId(runId, token, this.context.homeRuntimeId, kxmMonotonicNs());
             const openedMeta = appendDriveOpened(this.context, runId, driveId, options.mode);
-            const startedState = foldStoredVnextRun(this.context, requireRun(this.context, runId));
+            const startedState = foldStoredKxmRun(this.context, requireRun(this.context, runId));
             const deadlineAt = driveDeadlineAt(this.context, runId, startedState);
-            const session: VnextDriveSession = {
+            const session: KxmDriveSession = {
               driveId,
               runId,
               token,
@@ -764,7 +764,7 @@ export class VnextRunScheduler {
               settled,
               ...(deadlineAt !== undefined ? { deadlineAt } : {}),
             };
-            attachVnextDriveSession(this.context.eventStore.path, runId, token, session);
+            attachKxmDriveSession(this.context.eventStore.path, runId, token, session);
             opened = true;
             resolveOpen({ driveId, settled });
             try {
@@ -783,12 +783,12 @@ export class VnextRunScheduler {
               recordBareDriveFailure(this.context, runId);
               let foldedStatus: string | undefined;
               try {
-                foldedStatus = foldStoredVnextRun(this.context, requireRun(this.context, runId)).status;
+                foldedStatus = foldStoredKxmRun(this.context, requireRun(this.context, runId)).status;
               } catch {
                 foldedStatus = undefined;
               }
               recordDriveReceipt(this.context, session, {
-                kind: foldedStatus !== undefined && isTerminalRunStatus(foldedStatus as VnextRunStatus) ? "terminal" : "unsettled",
+                kind: foldedStatus !== undefined && isTerminalRunStatus(foldedStatus as KxmRunStatus) ? "terminal" : "unsettled",
                 error: driveErrorSummary(error),
                 producerId: producer.id,
                 producerClosed: false,
@@ -798,10 +798,10 @@ export class VnextRunScheduler {
             }
           } finally {
             if (producer) await closeDriveProducer(producer);
-            clearVnextDriveSession(this.context.eventStore.path, runId, token);
+            clearKxmDriveSession(this.context.eventStore.path, runId, token);
           }
         },
-      ) as Promise<VnextRunDriveResult>;
+      ) as Promise<KxmRunDriveResult>;
       void queued.then(undefined, (error) => {
         if (!opened) {
           rejectOpen(error);
@@ -811,19 +811,19 @@ export class VnextRunScheduler {
   }
 }
 
-export function verifyVnextAttemptCapability(
-  context: VnextRuntimeContext,
+export function verifyKxmAttemptCapability(
+  context: KxmRuntimeContext,
   presented: string,
   expected: { runId: string; attemptId: string },
-): VnextAttemptCapabilityRecord {
+): KxmAttemptCapabilityRecord {
   const presentedHash = hashCapabilitySecret(presented);
   const row = context.eventStore.capabilityByHash(presentedHash);
   const run = context.eventStore.run(expected.runId);
-  const folded = run ? foldStoredVnextRun(context, run) : undefined;
+  const folded = run ? foldStoredKxmRun(context, run) : undefined;
   const hashBuf = Buffer.from(presentedHash);
   const storedBuf = Buffer.from(row?.capabilityHash ?? presentedHash);
   const hashMatch = hashBuf.length === storedBuf.length && timingSafeEqual(hashBuf, storedBuf);
-  const located = vnextFoldPanelAttempt(folded?.currentStep, expected.attemptId);
+  const located = kxmFoldPanelAttempt(folded?.currentStep, expected.attemptId);
   const ok = Boolean(
     hashMatch
     && row
@@ -851,10 +851,10 @@ export function verifyVnextAttemptCapability(
 }
 
 function invokeProducer(
-  producer: VnextProducer,
-  request: VnextProducerRequest,
-): Promise<{ result?: VnextProducerResult; error: boolean; errorCode?: string }> {
-  let pending: Promise<VnextProducerResult>;
+  producer: KxmProducer,
+  request: KxmProducerRequest,
+): Promise<{ result?: KxmProducerResult; error: boolean; errorCode?: string }> {
+  let pending: Promise<KxmProducerResult>;
   try {
     pending = Promise.resolve(producer.produce(request));
   } catch {
@@ -866,31 +866,31 @@ function invokeProducer(
   );
 }
 
-export interface VnextPreparedGateDispatch {
-  readonly run: VnextRunRecord;
-  readonly envelope: VnextRunPlanEnvelope;
+export interface KxmPreparedGateDispatch {
+  readonly run: KxmRunRecord;
+  readonly envelope: KxmRunPlanEnvelope;
   readonly stepId: string;
   readonly stepAttempt: number;
   readonly assignmentId: string;
   readonly attemptId: string;
   readonly effectId: string;
   readonly controller: AbortController;
-  readonly state: VnextRunState;
+  readonly state: KxmRunState;
 }
 
-export interface VnextGateDispatchSeams {
-  afterEvaluate?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  afterObservationWrite?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  afterUncertaintyWrite?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  afterSettlementCommit?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  afterSpawnRecord?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  beforeCommandSpawn?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
-  beforeCommandSettle?: ((prepared: VnextPreparedGateDispatch) => void) | undefined;
+export interface KxmGateDispatchSeams {
+  afterEvaluate?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  afterObservationWrite?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  afterUncertaintyWrite?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  afterSettlementCommit?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  afterSpawnRecord?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  beforeCommandSpawn?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
+  beforeCommandSettle?: ((prepared: KxmPreparedGateDispatch) => void) | undefined;
 }
 
-export const vnextGateDispatchSeams: VnextGateDispatchSeams = {};
+export const kxmGateDispatchSeams: KxmGateDispatchSeams = {};
 
-async function stepLocked(context: VnextRuntimeContext, runId: string, producer: VnextProducer, token: string): Promise<VnextRunDriveResult> {
+async function stepLocked(context: KxmRuntimeContext, runId: string, producer: KxmProducer, token: string): Promise<KxmRunDriveResult> {
   const prepared = context.eventStore.transaction(() => prepareDispatch(context, runId, producer.id));
   if (prepared.kind === "return") {
     return prepared.handoff ? { state: prepared.state, handoff: prepared.handoff } : { state: prepared.state };
@@ -908,15 +908,15 @@ async function stepLocked(context: VnextRuntimeContext, runId: string, producer:
     if (!definition || definition.kind !== "artifacts-exist") {
       throw runtimeError("run_events_illegal", prepared.run.runId, "prepared gate is not artifacts-exist");
     }
-    registerVnextAttemptController(context.eventStore.path, runId, { attemptId: prepared.attemptId, controller: prepared.controller });
+    registerKxmAttemptController(context.eventStore.path, runId, { attemptId: prepared.attemptId, controller: prepared.controller });
     const clearBudget = armRunDurationBudgetTimer(context, runId);
     try {
       const observation = evaluateArtifactsGate(context, definition);
-      vnextGateDispatchSeams.afterEvaluate?.(prepared);
+      kxmGateDispatchSeams.afterEvaluate?.(prepared);
       return context.eventStore.transaction(() => settlePreparedGate(context, prepared, observation));
     } finally {
       clearBudget();
-      unregisterVnextAttemptController(context.eventStore.path, runId, prepared.attemptId);
+      unregisterKxmAttemptController(context.eventStore.path, runId, prepared.attemptId);
     }
   }
 
@@ -924,11 +924,11 @@ async function stepLocked(context: VnextRuntimeContext, runId: string, producer:
 }
 
 async function runPreparedCommandGate(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   definition: { readonly kind: "command"; readonly argv: readonly string[]; readonly timeoutMs: number; readonly cwd?: "control" },
   token: string,
-): Promise<VnextRunDriveResult> {
+): Promise<KxmRunDriveResult> {
   assertCommandSeatbelt(definition.argv.join(" "));
   const storePath = context.eventStore.path;
   const observer = createCommandObserver({
@@ -936,17 +936,17 @@ async function runPreparedCommandGate(
     cwd: context.projectRoot,
     signal: prepared.controller.signal,
     onSpawned: () => {
-      if (isVnextRuntimeContextClosed(context)) return;
+      if (isKxmRuntimeContextClosed(context)) return;
       try {
         context.eventStore.transaction(() => {
           recordGateSpawnedInTransaction(context, prepared.run, prepared.envelope, prepared.stepId);
-          vnextGateDispatchSeams.afterSpawnRecord?.(prepared);
+          kxmGateDispatchSeams.afterSpawnRecord?.(prepared);
         });
       } catch (error) {
         // Mark the hold unsettled synchronously BEFORE the observer stop path
         // can take any fallible action (group signalling) on this attempt.
         try {
-          markVnextGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
+          markKxmGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
         } catch {
           // The hold is already unsettled or released; the original failure governs.
         }
@@ -954,25 +954,25 @@ async function runPreparedCommandGate(
       }
     },
   });
-  armVnextGateHold(storePath, prepared.run.runId, token, prepared.attemptId, () => observer.requestStop("cancel"));
-  registerVnextAttemptController(storePath, prepared.run.runId, { attemptId: prepared.attemptId, controller: prepared.controller });
+  armKxmGateHold(storePath, prepared.run.runId, token, prepared.attemptId, () => observer.requestStop("cancel"));
+  registerKxmAttemptController(storePath, prepared.run.runId, { attemptId: prepared.attemptId, controller: prepared.controller });
   const clearBudget = armRunDurationBudgetTimer(context, prepared.run.runId);
-  const unhookClose = registerVnextRuntimeCloseHook(context, () => {
+  const unhookClose = registerKxmRuntimeCloseHook(context, () => {
     try {
-      markVnextGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
+      markKxmGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
     } catch {
       // Hold may already be unsettled.
     }
-    dropVnextGateStopHook(storePath, prepared.run.runId, prepared.attemptId);
+    dropKxmGateStopHook(storePath, prepared.run.runId, prepared.attemptId);
     observer.beginBoundedCleanup();
   });
   try {
-    vnextGateDispatchSeams.beforeCommandSpawn?.(prepared);
+    kxmGateDispatchSeams.beforeCommandSpawn?.(prepared);
     const outcome = await observer.run();
-    dropVnextGateStopHook(storePath, prepared.run.runId, prepared.attemptId);
-    if (isVnextRuntimeContextClosed(context)) {
+    dropKxmGateStopHook(storePath, prepared.run.runId, prepared.attemptId);
+    if (isKxmRuntimeContextClosed(context)) {
       try {
-        markVnextGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
+        markKxmGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
       } catch {
         // already unsettled
       }
@@ -985,15 +985,15 @@ async function runPreparedCommandGate(
     }
     if (outcome.kind === "complete") {
       try {
-        vnextGateDispatchSeams.beforeCommandSettle?.(prepared);
+        kxmGateDispatchSeams.beforeCommandSettle?.(prepared);
       } catch (error) {
         // Retain the unsettled hold and attempt a truthful recording-error
         // uncertainty only if no observation was committed.
         return recoverCommandRecordingFailure(context, prepared, token, outcome.observation, error);
       }
-      if (isVnextRuntimeContextClosed(context)) {
+      if (isKxmRuntimeContextClosed(context)) {
         try {
-          markVnextGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
+          markKxmGateHoldUnsettled(storePath, prepared.run.runId, token, prepared.attemptId);
         } catch {
           // already unsettled
         }
@@ -1005,18 +1005,18 @@ async function runPreparedCommandGate(
   } finally {
     unhookClose();
     clearBudget();
-    unregisterVnextAttemptController(storePath, prepared.run.runId, prepared.attemptId);
+    unregisterKxmAttemptController(storePath, prepared.run.runId, prepared.attemptId);
   }
 }
 
 function closedCommandHandoff(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   reason: string,
-): VnextRunDriveResult {
-  let state: VnextRunDriveResult["state"];
+): KxmRunDriveResult {
+  let state: KxmRunDriveResult["state"];
   try {
-    state = foldStoredVnextRun(context, requireRun(context, prepared.run.runId));
+    state = foldStoredKxmRun(context, requireRun(context, prepared.run.runId));
   } catch {
     state = prepared.state;
   }
@@ -1032,25 +1032,25 @@ function closedCommandHandoff(
 }
 
 function commitOwnedCommandSettlement(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   token: string,
-  write: () => { state: VnextRunDriveResult["state"] },
-  observation: VnextGateObservationInput,
-): VnextRunDriveResult {
-  let committed: { state: VnextRunDriveResult["state"] };
+  write: () => { state: KxmRunDriveResult["state"] },
+  observation: KxmGateObservationInput,
+): KxmRunDriveResult {
+  let committed: { state: KxmRunDriveResult["state"] };
   try {
     committed = context.eventStore.transaction(() => write());
   } catch (error) {
     return recoverCommandRecordingFailure(context, prepared, token, observation, error);
   }
   try {
-    vnextGateDispatchSeams.afterSettlementCommit?.(prepared);
+    kxmGateDispatchSeams.afterSettlementCommit?.(prepared);
   } catch (error) {
     return retainCommittedCommandProof(context, prepared, token, error);
   }
   try {
-    finishVnextOwnedGate(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
+    finishKxmOwnedGate(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
   } catch (error) {
     return retainCommittedCommandProof(context, prepared, token, error);
   }
@@ -1058,8 +1058,8 @@ function commitOwnedCommandSettlement(
 }
 
 function retainCommittedCommandProof(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   token: string,
   error: unknown,
 ): never {
@@ -1072,11 +1072,11 @@ function retainCommittedCommandProof(
 }
 
 function finishOwnedGateAfterCommittedTerminalProof(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   token: string,
 ): void {
-  if (isVnextRuntimeContextClosed(context)) return;
+  if (isKxmRuntimeContextClosed(context)) return;
   const run = context.eventStore.run(prepared.run.runId);
   if (!run || run.projectId !== context.projectId || run.homeRuntimeId !== context.homeRuntimeId) return;
   const row = context.eventStore.gateAttempt(prepared.attemptId);
@@ -1095,7 +1095,7 @@ function finishOwnedGateAfterCommittedTerminalProof(
   const events = context.eventStore.events(prepared.run.runId, 0, 1_000_000);
   let state;
   try {
-    state = foldStoredVnextRun(context, run);
+    state = foldStoredKxmRun(context, run);
   } catch {
     return;
   }
@@ -1114,8 +1114,8 @@ function finishOwnedGateAfterCommittedTerminalProof(
   const terminalProof = isEvaluatedSettledProof(row, observation, evidence)
     || isExcludedTerminalProof(state, row, observation, evidence, events);
   if (!terminalProof) return;
-  const hold = vnextGateHold(context.eventStore.path, prepared.run.runId);
-  const admittedToken = vnextAdmittedToken(context.eventStore.path, prepared.run.runId);
+  const hold = kxmGateHold(context.eventStore.path, prepared.run.runId);
+  const admittedToken = kxmAdmittedToken(context.eventStore.path, prepared.run.runId);
   if (
     !hold
     || hold.state !== "active"
@@ -1125,18 +1125,18 @@ function finishOwnedGateAfterCommittedTerminalProof(
   ) {
     return;
   }
-  finishVnextOwnedGate(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
+  finishKxmOwnedGate(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
 }
 
 function recoverCommandRecordingFailure(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   token: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
   error: unknown,
-): VnextRunDriveResult {
-  markVnextGateHoldUnsettled(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
-  if (isVnextRuntimeContextClosed(context)) {
+): KxmRunDriveResult {
+  markKxmGateHoldUnsettled(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
+  if (isKxmRuntimeContextClosed(context)) {
     throw error;
   }
   const existing = context.eventStore.gateObservationForAttempt(prepared.attemptId);
@@ -1147,7 +1147,7 @@ function recoverCommandRecordingFailure(
       `command observation recording failed after committed proof: ${error instanceof Error ? error.message : String(error)}`,
     );
   }
-  const folded = foldStoredVnextRun(context, requireRun(context, prepared.run.runId));
+  const folded = foldStoredKxmRun(context, requireRun(context, prepared.run.runId));
   if (folded.currentStep?.attemptId === prepared.attemptId && folded.currentStep.observationId) {
     throw runtimeError(
       "run_events_illegal",
@@ -1155,7 +1155,7 @@ function recoverCommandRecordingFailure(
       "command observation recording failed after committed proof",
     );
   }
-  const incomplete: VnextGateObservationInput = {
+  const incomplete: KxmGateObservationInput = {
     ...observation,
     completeness: "incomplete",
     errorClass: observation.errorClass ?? "recording-error",
@@ -1165,19 +1165,19 @@ function recoverCommandRecordingFailure(
 }
 
 function commitCommandUncertainty(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
   token: string,
   reason: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
   priorError?: unknown,
-): VnextRunDriveResult {
+): KxmRunDriveResult {
   try {
-    markVnextGateHoldUnsettled(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
+    markKxmGateHoldUnsettled(context.eventStore.path, prepared.run.runId, token, prepared.attemptId);
   } catch {
     // already unsettled
   }
-  if (isVnextRuntimeContextClosed(context)) {
+  if (isKxmRuntimeContextClosed(context)) {
     if (priorError) throw priorError;
     return closedCommandHandoff(context, prepared, reason);
   }
@@ -1189,11 +1189,11 @@ function commitCommandUncertainty(
       "command observation already committed; uncertainty cannot replace it",
     );
   }
-  const incomplete: VnextGateObservationInput = { ...observation, completeness: "incomplete" };
+  const incomplete: KxmGateObservationInput = { ...observation, completeness: "incomplete" };
   try {
     const written = context.eventStore.transaction(() => {
       const result = recordGateUncertainInTransaction(context, prepared.run, prepared.envelope, prepared.stepId, reason, incomplete);
-      vnextGateDispatchSeams.afterUncertaintyWrite?.(prepared);
+      kxmGateDispatchSeams.afterUncertaintyWrite?.(prepared);
       return result;
     });
     return {
@@ -1212,9 +1212,9 @@ function commitCommandUncertainty(
 }
 
 interface PreparedDispatch {
-  run: VnextRunRecord;
-  plan: VnextCompiledPlan;
-  step: VnextCompiledStep;
+  run: KxmRunRecord;
+  plan: KxmCompiledPlan;
+  step: KxmCompiledStep;
   stepId: string;
   stepAttempt: number;
   assignmentId: string;
@@ -1222,42 +1222,42 @@ interface PreparedDispatch {
   agentId: string;
   capabilityHash: string;
   producerId: string;
-  request: VnextProducerRequest;
+  request: KxmProducerRequest;
   controller: AbortController;
-  state: VnextRunState;
+  state: KxmRunState;
 }
 
 interface PreparedPanel {
-  run: VnextRunRecord;
-  plan: VnextCompiledPlan;
-  step: VnextCompiledStep;
+  run: KxmRunRecord;
+  plan: KxmCompiledPlan;
+  step: KxmCompiledStep;
   stepId: string;
   stepAttempt: number;
   target: number;
   maxParallel: number;
   first: PreparedDispatch;
-  state: VnextRunState;
+  state: KxmRunState;
 }
 
-export interface VnextPanelMemberHook {
+export interface KxmPanelMemberHook {
   readonly attemptId: string;
   readonly assignmentId: string;
   readonly stepId: string;
   readonly stepAttempt: number;
 }
 
-export interface VnextPanelDispatchSeams {
-  afterBirth?: ((member: VnextPanelMemberHook) => void) | undefined;
-  beforeAppendExecuting?: ((member: VnextPanelMemberHook) => void) | undefined;
-  failAppendExecuting?: ((member: VnextPanelMemberHook) => boolean) | undefined;
-  beforeInvoke?: ((member: VnextPanelMemberHook) => void) | undefined;
-  failSettleMember?: ((member: VnextPanelMemberHook) => boolean) | undefined;
+export interface KxmPanelDispatchSeams {
+  afterBirth?: ((member: KxmPanelMemberHook) => void) | undefined;
+  beforeAppendExecuting?: ((member: KxmPanelMemberHook) => void) | undefined;
+  failAppendExecuting?: ((member: KxmPanelMemberHook) => boolean) | undefined;
+  beforeInvoke?: ((member: KxmPanelMemberHook) => void) | undefined;
+  failSettleMember?: ((member: KxmPanelMemberHook) => boolean) | undefined;
   skipDispatch?: (() => boolean) | undefined;
 }
 
-export const vnextPanelDispatchSeams: VnextPanelDispatchSeams = {};
+export const kxmPanelDispatchSeams: KxmPanelDispatchSeams = {};
 
-function unreconciledPanelAttemptId(state: VnextRunState): string | undefined {
+function unreconciledPanelAttemptId(state: KxmRunState): string | undefined {
   const current = state.currentStep;
   if (!current) return undefined;
   for (const assignmentId of current.panel.order) {
@@ -1274,9 +1274,9 @@ function unreconciledPanelAttemptId(state: VnextRunState): string | undefined {
 
 function resolveProducerRoute(
   projectRoot: string,
-  step: VnextCompiledStep,
+  step: KxmCompiledStep,
   agentId: string,
-): { provider: string; model: string; selector: string } | { error: Omit<VnextRunHandoff, "stepId"> } {
+): { provider: string; model: string; selector: string } | { error: Omit<KxmRunHandoff, "stepId"> } {
   let agentModel: string | undefined;
   const agentFile = join(projectRoot, ".kxm", "agents", `${agentId}.yaml`);
   if (existsSync(agentFile)) {
@@ -1346,17 +1346,17 @@ function resolveProducerRoute(
 }
 
 function prepareDispatch(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   runId: string,
   producerId?: "driver-simulated" | "pi" | string,
-): { kind: "panel"; panel: PreparedPanel } | { kind: "return"; state: VnextRunState; handoff?: VnextRunHandoff } | ({ kind: "gate" } & VnextPreparedGateDispatch) {
+): { kind: "panel"; panel: PreparedPanel } | { kind: "return"; state: KxmRunState; handoff?: KxmRunHandoff } | ({ kind: "gate" } & KxmPreparedGateDispatch) {
   const run = requireRun(context, runId);
-  const plan = rehydrateVnextCompiledPlanFromStore(context.eventStore, run);
-  const state = foldStoredVnextRun(context, run);
-  if (vnextPanelDispatchSeams.skipDispatch?.()) {
+  const plan = rehydrateKxmCompiledPlanFromStore(context.eventStore, run);
+  const state = foldStoredKxmRun(context, run);
+  if (kxmPanelDispatchSeams.skipDispatch?.()) {
     return { kind: "return", state };
   }
-  if (state.status === "cancelling" && vnextAttemptControllers(context.eventStore.path, runId).length === 0) {
+  if (state.status === "cancelling" && kxmAttemptControllers(context.eventStore.path, runId).length === 0) {
     return {
       kind: "return",
       state,
@@ -1439,7 +1439,7 @@ function prepareDispatch(
   }
 
   if (step.kind === "gate") {
-    const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
+    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
     const unsupported = unsupportedGateStep(plan, step, envelope, context);
     if (unsupported) return { kind: "return", state, handoff: { ...unsupported, stepId } };
     const definition = envelope.gates.definitions[step.gate];
@@ -1509,23 +1509,23 @@ function prepareDispatch(
   const stepAttempt = used + 1;
   const now = new Date().toISOString();
   let sequence = context.eventStore.nextSequence(runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [];
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [];
   const push = (eventType: string, payload: Record<string, unknown>): void => {
     events.push({
-      ...vnextEventBase(context, run, now, mono),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, mono),
+      eventId: newKxmEventId(),
       eventType,
       sequence: sequence++,
       payload,
     });
-    mono = vnextIncrementMonotonicNs(mono);
+    mono = kxmIncrementMonotonicNs(mono);
   };
   push("step.entered", { stepId, stepAttempt, status: "pending" });
   push("step.status_changed", { stepId, status: "preparing", previousStatus: "pending" });
   for (const event of events) context.eventStore.appendEvent(event);
-  const entered = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, runId, entered, events[events.length - 1]!.sequence);
+  const entered = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, runId, entered, events[events.length - 1]!.sequence);
   const first = birthMember(context, {
     run,
     plan,
@@ -1552,7 +1552,7 @@ function prepareDispatch(
   };
 }
 
-function panelInFlight(state: VnextRunState): number {
+function panelInFlight(state: KxmRunState): number {
   const current = state.currentStep;
   if (!current) return 0;
   let count = 0;
@@ -1566,7 +1566,7 @@ function panelInFlight(state: VnextRunState): number {
   return count;
 }
 
-function panelFrozenState(state: VnextRunState): boolean {
+function panelFrozenState(state: KxmRunState): boolean {
   const current = state.currentStep;
   if (!current) return true;
   return current.outcome !== undefined
@@ -1575,7 +1575,7 @@ function panelFrozenState(state: VnextRunState): boolean {
     || current.status === "cancelled";
 }
 
-function birthAllowed(state: VnextRunState, step: VnextCompiledStep): boolean {
+function birthAllowed(state: KxmRunState, step: KxmCompiledStep): boolean {
   if (state.status !== "running" || state.cancelRequested || panelFrozenState(state)) return false;
   const born = state.currentStep?.panel.order.length ?? 0;
   if (born >= step.assignments.target) return false;
@@ -1584,11 +1584,11 @@ function birthAllowed(state: VnextRunState, step: VnextCompiledStep): boolean {
 }
 
 function birthMember(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   input: {
-    run: VnextRunRecord;
-    plan: VnextCompiledPlan;
-    step: VnextCompiledStep;
+    run: KxmRunRecord;
+    plan: KxmCompiledPlan;
+    step: KxmCompiledStep;
     stepId: string;
     stepAttempt: number;
     enterRunning?: boolean | undefined;
@@ -1597,7 +1597,7 @@ function birthMember(
   },
 ): PreparedDispatch {
   const run = requireRun(context, input.run.runId);
-  const folded = foldStoredVnextRun(context, run);
+  const folded = foldStoredKxmRun(context, run);
   if (!birthAllowed(folded, input.step)) {
     throw runtimeError("run_events_illegal", run.runId, "member birth is not legal");
   }
@@ -1622,23 +1622,23 @@ function birthMember(
       resolvedRoute = routeResult;
     }
   }
-  const assignmentId = newVnextAssignmentId();
-  const attemptId = newVnextAttemptId();
+  const assignmentId = newKxmAssignmentId();
+  const attemptId = newKxmAttemptId();
   const minted = mintCapabilitySecret();
   const controller = new AbortController();
   const now = new Date().toISOString();
   let sequence = context.eventStore.nextSequence(run.runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [];
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [];
   const push = (eventType: string, payload: Record<string, unknown>): void => {
     events.push({
-      ...vnextEventBase(context, run, now, mono),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, mono),
+      eventId: newKxmEventId(),
       eventType,
       sequence: sequence++,
       payload,
     });
-    mono = vnextIncrementMonotonicNs(mono);
+    mono = kxmIncrementMonotonicNs(mono);
   };
   push("assignment.created", { assignmentId, stepId: input.stepId, stepAttempt: input.stepAttempt, agentId, status: "created" });
   push("assignment.accepted", { assignmentId, status: "accepted" });
@@ -1664,8 +1664,8 @@ function birthMember(
     capabilityHash: minted.hash,
     state: "issued",
   });
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
   const rawContextPacket = buildFormalContextPacket({
     project: run.projectId,
     targetRole: agentId,
@@ -1724,46 +1724,46 @@ function birthMember(
     controller,
     state: next,
   };
-  vnextPanelDispatchSeams.afterBirth?.(member);
+  kxmPanelDispatchSeams.afterBirth?.(member);
   return member;
 }
 
-function appendExecuting(context: VnextRuntimeContext, dispatch: PreparedDispatch): void {
+function appendExecuting(context: KxmRuntimeContext, dispatch: PreparedDispatch): void {
   const run = requireRun(context, dispatch.run.runId);
   const now = new Date().toISOString();
   let sequence = context.eventStore.nextSequence(dispatch.run.runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [
     {
-      ...vnextEventBase(context, run, now, mono),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, mono),
+      eventId: newKxmEventId(),
       eventType: "assignment.executing",
       sequence: sequence++,
       payload: { assignmentId: dispatch.assignmentId, status: "executing" },
     },
     {
-      ...vnextEventBase(context, run, now, vnextIncrementMonotonicNs(mono)),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, kxmIncrementMonotonicNs(mono)),
+      eventId: newKxmEventId(),
       eventType: "attempt.status_changed",
       sequence: sequence++,
       payload: { attemptId: dispatch.attemptId, status: "executing" },
     },
   ];
   for (const event of events) context.eventStore.appendEvent(event);
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
 }
 
 type MemberWork =
-  | { attemptId: string; invoked: true; produced: { result?: VnextProducerResult; error: boolean } }
+  | { attemptId: string; invoked: true; produced: { result?: KxmProducerResult; error: boolean } }
   | { attemptId: string; invoked: false; skipped: true }
   | { attemptId: string; invoked: false; appendFailed: true; error: unknown };
 
-function singletonPanel(step: VnextCompiledStep): boolean {
+function singletonPanel(step: KxmCompiledStep): boolean {
   return step.assignments.maximum === 1 && step.assignments.target === 1;
 }
 
-function unreconciledHandoff(state: VnextRunState, stepId: string, attemptId?: string): VnextRunDriveResult {
+function unreconciledHandoff(state: KxmRunState, stepId: string, attemptId?: string): KxmRunDriveResult {
   return {
     state,
     handoff: {
@@ -1782,9 +1782,9 @@ function capabilityHashBound(stored: string, minted: string): boolean {
 }
 
 function capabilityMatchesDispatch(
-  capability: VnextAttemptCapabilityRow | undefined,
+  capability: KxmAttemptCapabilityRow | undefined,
   member: PreparedDispatch,
-  allowedStates: ReadonlyArray<VnextAttemptCapabilityRow["state"]>,
+  allowedStates: ReadonlyArray<KxmAttemptCapabilityRow["state"]>,
   expectedProducerId?: string,
 ): boolean {
   return Boolean(
@@ -1801,10 +1801,10 @@ function capabilityMatchesDispatch(
 }
 
 async function drivePanel(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   panel: PreparedPanel,
-  producer: VnextProducer,
-): Promise<VnextRunDriveResult> {
+  producer: KxmProducer,
+): Promise<KxmRunDriveResult> {
   const runId = panel.run.runId;
   const owned = new Map<string, PreparedDispatch>();
   const pending = new Map<string, Promise<MemberWork>>();
@@ -1813,7 +1813,7 @@ async function drivePanel(
 
   const budgetClears = new Map<string, () => void>();
   const register = (member: PreparedDispatch): void => {
-    registerVnextAttemptController(context.eventStore.path, runId, { attemptId: member.attemptId, controller: member.controller });
+    registerKxmAttemptController(context.eventStore.path, runId, { attemptId: member.attemptId, controller: member.controller });
     budgetClears.set(member.attemptId, armRunDurationBudgetTimer(context, runId));
     owned.set(member.attemptId, member);
   };
@@ -1826,15 +1826,15 @@ async function drivePanel(
     register(member);
     const work = (async (): Promise<MemberWork> => {
       try {
-        vnextPanelDispatchSeams.beforeAppendExecuting?.(member);
+        kxmPanelDispatchSeams.beforeAppendExecuting?.(member);
         const started = context.eventStore.transaction(() => {
-          if (vnextPanelDispatchSeams.failAppendExecuting?.(member)) {
+          if (kxmPanelDispatchSeams.failAppendExecuting?.(member)) {
             throw runtimeError("run_events_illegal", runId, "appendExecuting failed");
           }
           const run = requireRun(context, runId);
-          const state = foldStoredVnextRun(context, run);
+          const state = foldStoredKxmRun(context, run);
           const capability = context.eventStore.capabilityByAttempt(member.attemptId);
-          const located = vnextFoldPanelAttempt(state.currentStep, member.attemptId);
+          const located = kxmFoldPanelAttempt(state.currentStep, member.attemptId);
           if (
             state.cancelRequested
             || state.status === "cancelling"
@@ -1851,9 +1851,9 @@ async function drivePanel(
         if (!started) return { attemptId: member.attemptId, invoked: false, skipped: true };
         const executingBound = (): boolean => {
           const run = requireRun(context, runId);
-          const state = foldStoredVnextRun(context, run);
+          const state = foldStoredKxmRun(context, run);
           const capability = context.eventStore.capabilityByAttempt(member.attemptId);
-          const located = vnextFoldPanelAttempt(state.currentStep, member.attemptId);
+          const located = kxmFoldPanelAttempt(state.currentStep, member.attemptId);
           if (
             state.cancelRequested
             || state.status === "cancelling"
@@ -1867,7 +1867,7 @@ async function drivePanel(
           return true;
         };
         if (!executingBound()) return { attemptId: member.attemptId, invoked: false, skipped: true };
-        vnextPanelDispatchSeams.beforeInvoke?.(member);
+        kxmPanelDispatchSeams.beforeInvoke?.(member);
         if (!executingBound()) return { attemptId: member.attemptId, invoked: false, skipped: true };
         const produced = await invokeProducer(producer, member.request);
         return { attemptId: member.attemptId, invoked: true, produced };
@@ -1883,7 +1883,7 @@ async function drivePanel(
     if (stopBirths) return undefined;
     return context.eventStore.transaction(() => {
       const run = requireRun(context, runId);
-      const state = foldStoredVnextRun(context, run);
+      const state = foldStoredKxmRun(context, run);
       if (!birthAllowed(state, panel.step)) return undefined;
       return birthMember(context, {
         run,
@@ -1896,7 +1896,7 @@ async function drivePanel(
     });
   };
 
-  const settleInvoked = (member: PreparedDispatch, produced: { result?: VnextProducerResult; error: boolean }): boolean => {
+  const settleInvoked = (member: PreparedDispatch, produced: { result?: KxmProducerResult; error: boolean }): boolean => {
     if (produced.result?.effectUncertain) {
       settlementFailed = true;
       stopBirths = true;
@@ -1904,7 +1904,7 @@ async function drivePanel(
     }
     try {
       context.eventStore.transaction(() => {
-        if (vnextPanelDispatchSeams.failSettleMember?.(member)) {
+        if (kxmPanelDispatchSeams.failSettleMember?.(member)) {
           throw runtimeError("run_events_illegal", runId, "member settlement write failed");
         }
         settleMember(context, member, produced.result, produced.error);
@@ -1945,7 +1945,7 @@ async function drivePanel(
           stopBirths = true;
           abortOwned();
           await drainPendingInvoked();
-          const state = foldStoredVnextRun(context, requireRun(context, runId));
+          const state = foldStoredKxmRun(context, requireRun(context, runId));
           return unreconciledHandoff(state, panel.stepId);
         }
       }
@@ -1969,7 +1969,7 @@ async function drivePanel(
             settleInvoked(sibling, item.produced);
           }
         }
-        const state = foldStoredVnextRun(context, requireRun(context, runId));
+        const state = foldStoredKxmRun(context, requireRun(context, runId));
         return unreconciledHandoff(state, panel.stepId, member.attemptId);
       }
       if (!finished.invoked) {
@@ -1986,12 +1986,12 @@ async function drivePanel(
             settleInvoked(sibling, item.produced);
           }
         }
-        const state = foldStoredVnextRun(context, requireRun(context, runId));
+        const state = foldStoredKxmRun(context, requireRun(context, runId));
         return unreconciledHandoff(state, panel.stepId, member.attemptId);
       }
     }
 
-    const folded = foldStoredVnextRun(context, requireRun(context, runId));
+    const folded = foldStoredKxmRun(context, requireRun(context, runId));
     const leftover = unreconciledPanelAttemptId(folded);
     if (leftover || settlementFailed) {
       return unreconciledHandoff(folded, panel.stepId, leftover);
@@ -2001,7 +2001,7 @@ async function drivePanel(
       folded.currentStep
       && born > 0
       && folded.currentStep.panel.order.every((assignmentId) => folded.currentStep?.panel.assignments[assignmentId]?.status === "terminal")
-      && vnextFoldPanelAttemptIds(folded.currentStep).every((attemptId) => vnextFoldPanelAttempt(folded.currentStep, attemptId)?.attempt.status === "terminal"),
+      && kxmFoldPanelAttemptIds(folded.currentStep).every((attemptId) => kxmFoldPanelAttempt(folded.currentStep, attemptId)?.attempt.status === "terminal"),
     );
     if (!allTerminal) {
       return unreconciledHandoff(folded, panel.stepId, leftover);
@@ -2012,7 +2012,7 @@ async function drivePanel(
     try {
       return context.eventStore.transaction(() => joinPanel(context, panel));
     } catch {
-      const state = foldStoredVnextRun(context, requireRun(context, runId));
+      const state = foldStoredKxmRun(context, requireRun(context, runId));
       return unreconciledHandoff(state, panel.stepId);
     }
   } catch (error) {
@@ -2022,12 +2022,12 @@ async function drivePanel(
   } finally {
     for (const attemptId of owned.keys()) {
       budgetClears.get(attemptId)?.();
-      unregisterVnextAttemptController(context.eventStore.path, runId, attemptId);
+      unregisterKxmAttemptController(context.eventStore.path, runId, attemptId);
     }
   }
 }
 
-function producerRoutingRecord(context: VnextRuntimeContext, dispatch: PreparedDispatch, result: VnextProducerResult, now: string): RoutingRecordV2 {
+function producerRoutingRecord(context: KxmRuntimeContext, dispatch: PreparedDispatch, result: KxmProducerResult, now: string): RoutingRecordV2 {
   const run = requireRun(context, dispatch.run.runId);
   if (result.costBasis === undefined || result.costBasis === null) {
     throw runtimeError("settle_missing_cost_basis", run.runId, `attempt settlement rejected: missing required costBasis for attempt ${dispatch.attemptId}`);
@@ -2038,7 +2038,7 @@ function producerRoutingRecord(context: VnextRuntimeContext, dispatch: PreparedD
   if (result.costBasis === "metered" && (typeof result.costUsd !== "number" || !Number.isFinite(result.costUsd) || result.costUsd < 0)) {
     throw runtimeError("settle_invalid_cost", run.runId, "attempt settlement rejected: metered costBasis requires non-negative finite costUsd");
   }
-  const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
+  const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
   const rawHash = result.behavioralSha256 ?? behavioralConfigHash({
     requestedModel: result.requestedModel ?? "simulated",
     effectiveModel: result.effectiveModel ?? result.requestedModel ?? "simulated",
@@ -2065,15 +2065,15 @@ function producerRoutingRecord(context: VnextRuntimeContext, dispatch: PreparedD
 }
 
 function settleMember(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   dispatch: PreparedDispatch,
-  result: VnextProducerResult | undefined,
+  result: KxmProducerResult | undefined,
   produceError: boolean,
 ): void {
   const run = requireRun(context, dispatch.run.runId);
-  const state = foldStoredVnextRun(context, run);
+  const state = foldStoredKxmRun(context, run);
   const capability = context.eventStore.capabilityByAttempt(dispatch.attemptId);
-  const located = vnextFoldPanelAttempt(state.currentStep, dispatch.attemptId);
+  const located = kxmFoldPanelAttempt(state.currentStep, dispatch.attemptId);
   if (
     !located
     || located.assignmentId !== dispatch.assignmentId
@@ -2086,17 +2086,17 @@ function settleMember(
   const cancelling = state.status === "cancelling" || capability.state === "revoked";
   const now = new Date().toISOString();
   let sequence = context.eventStore.nextSequence(run.runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [];
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [];
   const push = (eventType: string, payload: Record<string, unknown>): void => {
     events.push({
-      ...vnextEventBase(context, run, now, mono),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, mono),
+      eventId: newKxmEventId(),
       eventType,
       sequence: sequence++,
       payload,
     });
-    mono = vnextIncrementMonotonicNs(mono);
+    mono = kxmIncrementMonotonicNs(mono);
   };
   push("attempt.status_changed", { attemptId: dispatch.attemptId, status: "settling" });
   if (cancelling) {
@@ -2106,7 +2106,7 @@ function settleMember(
     push("attempt.status_changed", { attemptId: dispatch.attemptId, status: "terminal" });
     push("assignment.terminal", { assignmentId: dispatch.assignmentId, outcome: "cancelled", status: "terminal" });
   } else if (produceError) {
-    const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
+    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
     const rawHash = result?.behavioralSha256 ?? behavioralConfigHash({
       requestedModel: result?.requestedModel ?? "simulated",
       effectiveModel: result?.effectiveModel ?? result?.requestedModel ?? "simulated",
@@ -2171,49 +2171,49 @@ function settleMember(
   }
   context.eventStore.settleCapability(dispatch.attemptId, "settled");
   for (const event of events) context.eventStore.appendEvent(event);
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
 }
 
-function joinPanel(context: VnextRuntimeContext, panel: PreparedPanel): VnextRunDriveResult {
+function joinPanel(context: KxmRuntimeContext, panel: PreparedPanel): KxmRunDriveResult {
   const run = requireRun(context, panel.run.runId);
-  const state = foldStoredVnextRun(context, run);
+  const state = foldStoredKxmRun(context, run);
   const current = state.currentStep;
   if (!current || current.stepId !== panel.stepId) {
     throw runtimeError("run_events_illegal", run.runId, "join attempted without the prepared step");
   }
-  const joined = vnextJoinAll(panel.step, current.panel);
+  const joined = kxmJoinAll(panel.step, current.panel);
   const now = new Date().toISOString();
   let sequence = context.eventStore.nextSequence(run.runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [];
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [];
   const push = (eventType: string, payload: Record<string, unknown>): void => {
     events.push({
-      ...vnextEventBase(context, run, now, mono),
-      eventId: newVnextEventId(),
+      ...kxmEventBase(context, run, now, mono),
+      eventId: newKxmEventId(),
       eventType,
       sequence: sequence++,
       payload,
     });
-    mono = vnextIncrementMonotonicNs(mono);
+    mono = kxmIncrementMonotonicNs(mono);
   };
 
-  const failRun = (reason: string): VnextRunDriveResult => {
+  const failRun = (reason: string): KxmRunDriveResult => {
     push("step.status_changed", { stepId: panel.stepId, status: "failed", previousStatus: "running" });
     push("run.status_changed", { status: "failed", reason, stepId: panel.stepId });
     for (const event of events) context.eventStore.appendEvent(event);
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
     context.eventStore.updateRunStatus(run.runId, "failed", now);
     return { state: next };
   };
 
-  const cancelRun = (): VnextRunDriveResult => {
+  const cancelRun = (): KxmRunDriveResult => {
     push("step.status_changed", { stepId: panel.stepId, status: "cancelled", previousStatus: "running" });
     push("run.status_changed", { status: "cancelled", reason: cancelReasonFromLog(context, run.runId) });
     for (const event of events) context.eventStore.appendEvent(event);
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
     context.eventStore.updateRunStatus(run.runId, "cancelled", now);
     return { state: next };
   };
@@ -2252,8 +2252,8 @@ function joinPanel(context: VnextRuntimeContext, panel: PreparedPanel): VnextRun
   if (budget) {
     push("run.status_changed", { status: "failed", reason: budget, stepId: panel.stepId, outcome });
     for (const event of events) context.eventStore.appendEvent(event);
-    const next = foldStoredVnextRun(context, run);
-    persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+    const next = foldStoredKxmRun(context, run);
+    persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
     context.eventStore.updateRunStatus(run.runId, "failed", now);
     return { state: next };
   }
@@ -2264,60 +2264,60 @@ function joinPanel(context: VnextRuntimeContext, panel: PreparedPanel): VnextRun
     push("run.status_changed", { status: selected.terminalStatus });
   }
   for (const event of events) context.eventStore.appendEvent(event);
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, events[events.length - 1]!.sequence);
-  context.eventStore.updateRunStatus(run.runId, next.status as VnextRunStatus, now);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, events[events.length - 1]!.sequence);
+  context.eventStore.updateRunStatus(run.runId, next.status as KxmRunStatus, now);
   return { state: next };
 }
 
 function failBudget(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  plan: VnextCompiledPlan,
-  state: VnextRunState,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  plan: KxmCompiledPlan,
+  state: KxmRunState,
   reason: string,
   stepId: string,
-): { state: VnextRunState } {
+): { state: KxmRunState } {
   const now = new Date().toISOString();
   const sequence = context.eventStore.nextSequence(run.runId);
-  const event: VnextRunEvent = {
-    ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-    eventId: newVnextEventId(),
+  const event: KxmRunEvent = {
+    ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+    eventId: newKxmEventId(),
     eventType: "run.status_changed",
     sequence,
     payload: { status: "failed", reason, stepId },
   };
   context.eventStore.appendEvent(event);
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, sequence);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, sequence);
   context.eventStore.updateRunStatus(run.runId, "failed", now);
   void state;
   return { state: next };
 }
 
-function hardStopUnrecorded(context: VnextRuntimeContext, dispatch: PreparedDispatch, reason: string): void {
+function hardStopUnrecorded(context: KxmRuntimeContext, dispatch: PreparedDispatch, reason: string): void {
   const run = requireRun(context, dispatch.run.runId);
   const now = new Date().toISOString();
   const sequence = context.eventStore.nextSequence(run.runId);
-  const event: VnextRunEvent = {
-    ...vnextEventBase(context, run, now, vnextMonotonicNs()),
-    eventId: newVnextEventId(),
+  const event: KxmRunEvent = {
+    ...kxmEventBase(context, run, now, kxmMonotonicNs()),
+    eventId: newKxmEventId(),
     eventType: "run.status_changed",
     sequence,
     payload: { status: "failed", reason, stepId: dispatch.stepId },
   };
   context.eventStore.appendEvent(event);
   context.eventStore.settleCapability(dispatch.attemptId, "revoked");
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, sequence);
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, sequence);
   context.eventStore.updateRunStatus(run.runId, "failed", now);
 }
 
-export function vnextTransitionBudgetFailure(plan: VnextCompiledPlan, state: VnextRunState, fromStepId: string, outcome: string): string | undefined {
+export function kxmTransitionBudgetFailure(plan: KxmCompiledPlan, state: KxmRunState, fromStepId: string, outcome: string): string | undefined {
   return transitionBudgetFailure(plan, state, fromStepId, outcome);
 }
 
-function transitionBudgetFailure(plan: VnextCompiledPlan, state: VnextRunState, fromStepId: string, outcome: string): string | undefined {
+function transitionBudgetFailure(plan: KxmCompiledPlan, state: KxmRunState, fromStepId: string, outcome: string): string | undefined {
   const selected = plan.steps[fromStepId]?.transitions[outcome];
   if (!selected) return "outcome_unknown";
   const edgeKey = `${fromStepId}:${outcome}`;
@@ -2341,11 +2341,11 @@ function elapsedMsBetween(fromIso: string, toIso: string): number {
   return Math.max(0, Math.trunc(to - from));
 }
 
-function declaredRunDurationBudget(context: VnextRuntimeContext, runId: string): VnextRunDurationBudget | undefined {
+function declaredRunDurationBudget(context: KxmRuntimeContext, runId: string): KxmRunDurationBudget | undefined {
   const run = context.eventStore.run(runId);
   if (!run) return undefined;
   try {
-    const envelope = loadVnextRunPlanEnvelope(context.eventStore, run);
+    const envelope = loadKxmRunPlanEnvelope(context.eventStore, run);
     return effectiveRunDurationBudget(envelope.plan.limits, envelope.projectLimits);
   } catch {
     return undefined;
@@ -2353,15 +2353,15 @@ function declaredRunDurationBudget(context: VnextRuntimeContext, runId: string):
 }
 
 function runDurationOverrunPayload(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   runId: string,
   nowIso = new Date().toISOString(),
-): { budgetMs: number; elapsedMs: number; source: VnextRunDurationBudget["source"] } | undefined {
+): { budgetMs: number; elapsedMs: number; source: KxmRunDurationBudget["source"] } | undefined {
   const declared = declaredRunDurationBudget(context, runId);
   if (!declared) return undefined;
   const run = context.eventStore.run(runId);
   if (!run) return undefined;
-  const state = foldStoredVnextRun(context, run);
+  const state = foldStoredKxmRun(context, run);
   if (!state.runningSince) return undefined;
   if (isTerminalRunStatus(state.status) || state.status === "cancelling") return undefined;
   const elapsedMs = elapsedMsBetween(state.runningSince, nowIso);
@@ -2369,15 +2369,15 @@ function runDurationOverrunPayload(
   return { budgetMs: declared.budgetMs, elapsedMs, source: declared.source };
 }
 
-function cancelRunDurationIfExceeded(context: VnextRuntimeContext, runId: string): VnextRunDriveResult | undefined {
-  if (isVnextRuntimeContextClosed(context)) return undefined;
+function cancelRunDurationIfExceeded(context: KxmRuntimeContext, runId: string): KxmRunDriveResult | undefined {
+  if (isKxmRuntimeContextClosed(context)) return undefined;
   const payload = runDurationOverrunPayload(context, runId);
   if (!payload) return undefined;
-  cancelVnextRun(context, runId, { reason: "budget_run_duration", budget: payload });
-  return { state: foldStoredVnextRun(context, requireRun(context, runId)) };
+  cancelKxmRun(context, runId, { reason: "budget_run_duration", budget: payload });
+  return { state: foldStoredKxmRun(context, requireRun(context, runId)) };
 }
 
-function driveDeadlineAt(context: VnextRuntimeContext, runId: string, state: VnextRunState): string | undefined {
+function driveDeadlineAt(context: KxmRuntimeContext, runId: string, state: KxmRunState): string | undefined {
   const declared = declaredRunDurationBudget(context, runId);
   if (!declared || !state.runningSince) return undefined;
   const start = Date.parse(state.runningSince);
@@ -2386,12 +2386,12 @@ function driveDeadlineAt(context: VnextRuntimeContext, runId: string, state: Vne
 }
 
 function driveReceiptBudget(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   runId: string,
-  state: VnextRunState,
-  events: readonly VnextRunEvent[],
+  state: KxmRunState,
+  events: readonly KxmRunEvent[],
   closedAt: string,
-): VnextDriveReceiptBudget | null {
+): KxmDriveReceiptBudget | null {
   const declared = declaredRunDurationBudget(context, runId);
   if (!declared) return null;
   const elapsedMs = state.runningSince ? elapsedMsBetween(state.runningSince, closedAt) : 0;
@@ -2406,7 +2406,7 @@ function driveReceiptBudget(
   };
 }
 
-function cancelReasonFromLog(context: VnextRuntimeContext, runId: string): string {
+function cancelReasonFromLog(context: KxmRuntimeContext, runId: string): string {
   const events = context.eventStore.events(runId, 0, 1_000_000);
   for (let index = events.length - 1; index >= 0; index -= 1) {
     const event = events[index]!;
@@ -2417,12 +2417,12 @@ function cancelReasonFromLog(context: VnextRuntimeContext, runId: string): strin
   return "operator_cancel";
 }
 
-function armRunDurationBudgetTimer(context: VnextRuntimeContext, runId: string): () => void {
+function armRunDurationBudgetTimer(context: KxmRuntimeContext, runId: string): () => void {
   const declared = declaredRunDurationBudget(context, runId);
   if (!declared) return () => undefined;
   const run = context.eventStore.run(runId);
   if (!run) return () => undefined;
-  const state = foldStoredVnextRun(context, run);
+  const state = foldStoredKxmRun(context, run);
   if (!state.runningSince) return () => undefined;
   const startMs = Date.parse(state.runningSince);
   if (!Number.isFinite(startMs)) return () => undefined;
@@ -2431,7 +2431,7 @@ function armRunDurationBudgetTimer(context: VnextRuntimeContext, runId: string):
   let cleared = false;
   const fire = (): void => {
     timer = undefined;
-    if (cleared || isVnextRuntimeContextClosed(context)) return;
+    if (cleared || isKxmRuntimeContextClosed(context)) return;
     const nowIso = new Date().toISOString();
     const elapsedMs = elapsedMsBetween(state.runningSince!, nowIso);
     if (elapsedMs < declared.budgetMs) {
@@ -2439,7 +2439,7 @@ function armRunDurationBudgetTimer(context: VnextRuntimeContext, runId: string):
       return;
     }
     try {
-      cancelVnextRun(context, runId, {
+      cancelKxmRun(context, runId, {
         reason: "budget_run_duration",
         budget: { budgetMs: declared.budgetMs, elapsedMs, source: declared.source },
       });
@@ -2453,7 +2453,7 @@ function armRunDurationBudgetTimer(context: VnextRuntimeContext, runId: string):
     timer = setTimeout(fire, delay);
     timer.unref();
   };
-  const unhook = registerVnextRuntimeCloseHook(context, () => {
+  const unhook = registerKxmRuntimeCloseHook(context, () => {
     cleared = true;
     if (timer !== undefined) clearTimeout(timer);
     timer = undefined;
@@ -2468,7 +2468,7 @@ function armRunDurationBudgetTimer(context: VnextRuntimeContext, runId: string):
   };
 }
 
-function unsupportedLimit(envelope: VnextRunPlanEnvelope): VnextRunHandoff | undefined {
+function unsupportedLimit(envelope: KxmRunPlanEnvelope): KxmRunHandoff | undefined {
   if (envelope.plan.limits.maxAgentTimeMs !== undefined) {
     return { reason: "limit_unsupported", field: "limits.maxAgentTimeMs", detail: "agent-time budget enforcement is not available in this slice" };
   }
@@ -2479,10 +2479,10 @@ function unsupportedLimit(envelope: VnextRunPlanEnvelope): VnextRunHandoff | und
 }
 
 function unsupportedStep(
-  plan: VnextCompiledPlan,
-  step: VnextCompiledStep,
+  plan: KxmCompiledPlan,
+  step: KxmCompiledStep,
   producerId?: "driver-simulated" | "pi" | string,
-): Omit<VnextRunHandoff, "stepId"> | undefined {
+): Omit<KxmRunHandoff, "stepId"> | undefined {
   if (step.kind === "gate") throw runtimeError("run_plan_corrupt", plan.workflowId, `unsupportedStep called on gate without envelope; use unsupportedGateStep instead`);
   if (step.kind !== "agent" && step.kind !== "moa" && step.kind !== "approval" && step.kind !== "wait") {
     return { reason: "step_unsupported", field: "kind", detail: `step kind ${step.kind} is not executed in this slice` };
@@ -2531,7 +2531,7 @@ function unsupportedStep(
   return undefined;
 }
 
-function unsupportedGateStep(plan: VnextCompiledPlan, step: VnextCompiledStep & { kind: "gate" }, envelope: VnextRunPlanEnvelope, context?: { projectRoot: string }): Omit<VnextRunHandoff, "stepId"> | undefined {
+function unsupportedGateStep(plan: KxmCompiledPlan, step: KxmCompiledStep & { kind: "gate" }, envelope: KxmRunPlanEnvelope, context?: { projectRoot: string }): Omit<KxmRunHandoff, "stepId"> | undefined {
   if (!step.gate) return { reason: "step_unsupported", field: "gate", detail: "gate step is missing gate id" };
   if (envelope.gates.registry === null) {
     return { reason: "step_unsupported", field: "gate", detail: `step ${step.id} refers to a gate but registry is null` };
@@ -2672,15 +2672,15 @@ function unsupportedGateStep(plan: VnextCompiledPlan, step: VnextCompiledStep &
 }
 
 function pinnedGatesForCompiledPlan(
-  plan: VnextCompiledPlan,
-  bundle: VnextProjectBundle,
+  plan: KxmCompiledPlan,
+  bundle: KxmProjectBundle,
   projectRoot: string,
-): VnextPinnedGates {
+): KxmPinnedGates {
   const referenced = new Set<string>();
   for (const step of Object.values(plan.steps)) {
     if (step.kind === "gate") referenced.add(step.gate);
   }
-  const definitions = Object.create(null) as VnextPinnedGates["definitions"] extends Readonly<infer T> ? T : Record<string, never>;
+  const definitions = Object.create(null) as KxmPinnedGates["definitions"] extends Readonly<infer T> ? T : Record<string, never>;
   const registryValue = bundle.gateRegistry?.value;
   const gatesObject = registryValue && typeof registryValue.gates === "object" && registryValue.gates && !Array.isArray(registryValue.gates)
     ? registryValue.gates as Record<string, unknown>
@@ -2694,7 +2694,7 @@ function pinnedGatesForCompiledPlan(
       : bundle.gateRegistry && referenced.size === 0
       ? { schema: "kxm.gate-registry.v1", hash: gateRegistryHash(bundle.gateRegistry.value) }
       : null,
-    definitions: definitions as VnextPinnedGates["definitions"],
+    definitions: definitions as KxmPinnedGates["definitions"],
     controlRoot: { repositoryId: "control", projectKey: projectRuntimeKey(projectRoot) },
   };
 }
@@ -2704,7 +2704,7 @@ export interface GateRecoveryPreflightResult {
   blocking: Array<{ runId: string; attemptId: string }>;
 }
 
-export function gateRecoveryPreflight(context: VnextRuntimeContext): GateRecoveryPreflightResult {
+export function gateRecoveryPreflight(context: KxmRuntimeContext): GateRecoveryPreflightResult {
   const attempts = context.eventStore.gateAttemptsForProject(context.projectId);
   const capabilities = context.eventStore.issuedOrRevokedCapabilities();
   const seenAttempts = new Set<string>();
@@ -2750,9 +2750,9 @@ export function gateRecoveryPreflight(context: VnextRuntimeContext): GateRecover
 }
 
 function classifyRecoverableGateAttempt(
-  context: VnextRuntimeContext,
-  row: VnextGateAttemptRow,
-  capability: VnextAttemptCapabilityRow | undefined,
+  context: KxmRuntimeContext,
+  row: KxmGateAttemptRow,
+  capability: KxmAttemptCapabilityRow | undefined,
 ): "excluded" | "owned" | "blocking" {
   if (row.producerId !== "kxm-gate") {
     throw runtimeError(
@@ -2789,7 +2789,7 @@ function classifyRecoverableGateAttempt(
   }
   let state;
   try {
-    state = foldStoredVnextRun(context, run);
+    state = foldStoredKxmRun(context, run);
   } catch (error) {
     throw runtimeError(
       "gate_recovery_corrupt",
@@ -2832,10 +2832,10 @@ function classifyRecoverableGateAttempt(
     && current.assignmentId === row.assignmentId
     && current.effectId === row.effectId
     && current.stepId === row.stepId;
-  const controller = vnextAttemptController(context.eventStore.path, row.runId, row.attemptId);
+  const controller = kxmAttemptController(context.eventStore.path, row.runId, row.attemptId);
   if (row.gateKind === "command") {
-    const hold = vnextGateHold(context.eventStore.path, row.runId);
-    const admittedToken = vnextAdmittedToken(context.eventStore.path, row.runId);
+    const hold = kxmGateHold(context.eventStore.path, row.runId);
+    const admittedToken = kxmAdmittedToken(context.eventStore.path, row.runId);
     if (hold && hold.attemptId !== row.attemptId) {
       throw runtimeError("gate_recovery_corrupt", row.attemptId, "gate recovery preflight: gate hold does not match the attempt");
     }
@@ -2874,8 +2874,8 @@ function gateRowIdentityMatches(
 
 function isEvaluatedSettledProof(
   row: { attemptId: string; assignmentId: string; effectId: string; stepId: string; runId: string },
-  observation: VnextGateObservationRow | undefined,
-  evidence: VnextGateEvidenceRow | undefined,
+  observation: KxmGateObservationRow | undefined,
+  evidence: KxmGateEvidenceRow | undefined,
 ): boolean {
   if (!evidence || !observation) return false;
   if (!gateRowIdentityMatches(row, observation) || !gateRowIdentityMatches(row, evidence)) return false;
@@ -2884,9 +2884,9 @@ function isEvaluatedSettledProof(
 }
 
 function proofOnlySettledEvent(
-  events: readonly VnextRunEvent[],
+  events: readonly KxmRunEvent[],
   row: { attemptId: string; assignmentId: string; effectId: string; stepId: string; runId: string },
-): VnextRunEvent | undefined {
+): KxmRunEvent | undefined {
   return events.find((event) => {
     if (event.eventType !== "effect.settled" || event.runId !== row.runId) return false;
     if (
@@ -2903,11 +2903,11 @@ function proofOnlySettledEvent(
 }
 
 function isExcludedTerminalProof(
-  state: VnextRunState,
+  state: KxmRunState,
   row: { attemptId: string; assignmentId: string; effectId: string; stepId: string; runId: string; stepAttempt?: number },
-  observation: VnextGateObservationRow | undefined,
-  evidence: VnextGateEvidenceRow | undefined,
-  events: readonly VnextRunEvent[],
+  observation: KxmGateObservationRow | undefined,
+  evidence: KxmGateEvidenceRow | undefined,
+  events: readonly KxmRunEvent[],
 ): boolean {
   if (evidence) return false;
   if (!observation) return false;
@@ -2944,12 +2944,12 @@ function isExcludedTerminalProof(
 }
 
 function settlePreparedGate(
-  context: VnextRuntimeContext,
-  prepared: VnextPreparedGateDispatch,
-  observation: VnextGateObservationInput,
+  context: KxmRuntimeContext,
+  prepared: KxmPreparedGateDispatch,
+  observation: KxmGateObservationInput,
 ) {
   const run = requireRun(context, prepared.run.runId);
-  const folded = foldStoredVnextRun(context, run);
+  const folded = foldStoredKxmRun(context, run);
   const current = folded.currentStep;
   if (
     !current
@@ -2981,11 +2981,11 @@ function settlePreparedGate(
   const settled = cancelled
     ? recordGateCancelObservedInTransaction(context, run, prepared.envelope, prepared.stepId, observation)
     : recordGateSettlementInTransaction(context, run, prepared.envelope, prepared.stepId, observation);
-  vnextGateDispatchSeams.afterObservationWrite?.(prepared);
+  kxmGateDispatchSeams.afterObservationWrite?.(prepared);
   return settled;
 }
 
-function requireRun(context: VnextRuntimeContext, runId: string): VnextRunRecord {
+function requireRun(context: KxmRuntimeContext, runId: string): KxmRunRecord {
   const run = context.eventStore.run(runId);
   if (!run) throw runtimeError("run_unknown", runId, "run does not exist in this event store");
   if (run.projectId !== context.projectId || run.homeRuntimeId !== context.homeRuntimeId) {
@@ -2994,20 +2994,20 @@ function requireRun(context: VnextRuntimeContext, runId: string): VnextRunRecord
   return run;
 }
 
-export interface VnextGateRecoveryRequest {
+export interface KxmGateRecoveryRequest {
   action: "retry" | "fail" | "cancel" | "unblock";
   reason?: string;
   commandId?: string;
 }
 
-export function recoverVnextRun(
-  context: VnextRuntimeContext,
+export function recoverKxmRun(
+  context: KxmRuntimeContext,
   runId: string,
-  request: VnextGateRecoveryRequest,
-): { state: VnextRunState; unblocked: boolean } {
+  request: KxmGateRecoveryRequest,
+): { state: KxmRunState; unblocked: boolean } {
   return context.eventStore.transaction(() => {
     const run = requireRun(context, runId);
-    let state = foldStoredVnextRun(context, run);
+    let state = foldStoredKxmRun(context, run);
 
     if (state.status !== "blocked_uncertain" && state.status !== "cancelling" && state.currentStep?.effectState !== "blocked_uncertain") {
       throw runtimeError("run_events_illegal", runId, `run ${runId} is not in blocked_uncertain status`);
@@ -3018,17 +3018,17 @@ export function recoverVnextRun(
 
     const now = new Date().toISOString();
     let sequence = context.eventStore.nextSequence(runId);
-    let mono = vnextMonotonicNs();
-    const events: VnextRunEvent[] = [];
+    let mono = kxmMonotonicNs();
+    const events: KxmRunEvent[] = [];
     const push = (eventType: string, payload: Record<string, unknown>): void => {
       events.push({
-        ...vnextEventBase(context, run, now, mono, request.commandId),
-        eventId: newVnextEventId(),
+        ...kxmEventBase(context, run, now, mono, request.commandId),
+        eventId: newKxmEventId(),
         eventType,
         sequence: sequence++,
         payload,
       });
-      mono = vnextIncrementMonotonicNs(mono);
+      mono = kxmIncrementMonotonicNs(mono);
     };
 
     if (state.status === "running" && state.currentStep?.effectState === "blocked_uncertain") {
@@ -3039,14 +3039,14 @@ export function recoverVnextRun(
       });
       for (const ev of events) context.eventStore.appendEvent(ev);
       events.length = 0;
-      state = foldStoredVnextRun(context, run);
+      state = foldStoredKxmRun(context, run);
       context.eventStore.updateRunStatus(runId, "blocked_uncertain", now);
     }
 
     const attemptId = state.currentStep?.attemptId;
     if (attemptId) {
-      resolveVnextGateHold(context.eventStore.path, runId, attemptId);
-      unregisterVnextAttemptController(context.eventStore.path, runId, attemptId);
+      resolveKxmGateHold(context.eventStore.path, runId, attemptId);
+      unregisterKxmAttemptController(context.eventStore.path, runId, attemptId);
       const cap = context.eventStore.capabilityByAttempt(attemptId);
       if (cap && cap.state !== "settled") {
         context.eventStore.settleCapability(attemptId, "settled");
@@ -3060,8 +3060,8 @@ export function recoverVnextRun(
         reason: request.reason ?? "operator_retry",
       });
       for (const ev of events) context.eventStore.appendEvent(ev);
-      const nextState = foldStoredVnextRun(context, run);
-      persistVnextRunState(context, runId, nextState, events[events.length - 1]!.sequence);
+      const nextState = foldStoredKxmRun(context, run);
+      persistKxmRunState(context, runId, nextState, events[events.length - 1]!.sequence);
       context.eventStore.updateRunStatus(runId, "running", now);
       return { state: nextState, unblocked: true };
     }
@@ -3073,8 +3073,8 @@ export function recoverVnextRun(
         reason: request.reason ?? "operator_fail",
       });
       for (const ev of events) context.eventStore.appendEvent(ev);
-      const nextState = foldStoredVnextRun(context, run);
-      persistVnextRunState(context, runId, nextState, events[events.length - 1]!.sequence);
+      const nextState = foldStoredKxmRun(context, run);
+      persistKxmRunState(context, runId, nextState, events[events.length - 1]!.sequence);
       context.eventStore.updateRunStatus(runId, "failed", now);
       return { state: nextState, unblocked: true };
     }
@@ -3095,8 +3095,8 @@ export function recoverVnextRun(
         reason: request.reason ?? "operator_cancel",
       });
       for (const ev of events) context.eventStore.appendEvent(ev);
-      const nextState = foldStoredVnextRun(context, run);
-      persistVnextRunState(context, runId, nextState, events[events.length - 1]!.sequence);
+      const nextState = foldStoredKxmRun(context, run);
+      persistKxmRunState(context, runId, nextState, events[events.length - 1]!.sequence);
       context.eventStore.updateRunStatus(runId, "cancelled", now);
       return { state: nextState, unblocked: true };
     }