@kontextmind/kxm 0.7.40 → 0.7.43

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

@@ -3,50 +3,50 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ContextItem } from "./context.ts";
 import {
-  VnextConfigError,
-  loadVnextProject,
-  vnextCanonicalJson,
+  KxmConfigError,
+  loadKxmProject,
+  kxmCanonicalJson,
   type JsonObject,
   type JsonValue,
-  type VnextConfigOptions,
-  type VnextProjectBundle,
-} from "./vnext-config.ts";
-import { foldVnextRunState, isTerminalRunStatus, VNEXT_RUN_STATE_SCHEMA, vnextFoldPanelAttemptIds, type VnextRunState } from "./vnext-engine-fold.ts";
-import { verifyVnextGateEvidence } from "./vnext-engine-evidence.ts";
-import { loadVnextRunPlanEnvelope } from "./vnext-engine-plan.ts";
+  type KxmConfigOptions,
+  type KxmProjectBundle,
+} from "./project-config.ts";
+import { foldKxmRunState, isTerminalRunStatus, KXM_RUN_STATE_SCHEMA, kxmFoldPanelAttemptIds, type KxmRunState } from "./engine-fold.ts";
+import { verifyKxmGateEvidence } from "./engine-evidence.ts";
+import { loadKxmRunPlanEnvelope } from "./engine-plan.ts";
 import {
-  registerVnextRuntimeHandle,
-  resolveVnextGateHold,
-  unregisterVnextRuntimeHandle,
-  vnextAttemptControllers,
-} from "./vnext-runtime-owner.ts";
+  registerKxmRuntimeHandle,
+  resolveKxmGateHold,
+  unregisterKxmRuntimeHandle,
+  kxmAttemptControllers,
+} from "./runtime-owner.ts";
 import {
-  VNEXT_ABSENT_MEMORY_REVISION,
-  VNEXT_RUN_EVENT_SCHEMA,
-  VnextRunEventStore,
-  VnextRuntimeRegistry,
-  newVnextCommandId,
-  newVnextEventId,
-  newVnextRunId,
+  KXM_ABSENT_MEMORY_REVISION,
+  KXM_RUN_EVENT_SCHEMA,
+  KxmRunEventStore,
+  KxmRuntimeRegistry,
+  newKxmCommandId,
+  newKxmEventId,
+  newKxmRunId,
   runtimeError,
-  vnextRuntimePaths,
-  type VnextRunEvent,
-  type VnextRunRecord,
-  type VnextRunStatus,
-} from "./vnext-runtime-store.ts";
+  kxmRuntimePaths,
+  type KxmRunEvent,
+  type KxmRunRecord,
+  type KxmRunStatus,
+} from "./runtime-store.ts";
 
 /* ------------------------------------------------------------------ *
  * Policy revisions derived deterministically from the bundle
  * ------------------------------------------------------------------ */
 
-export interface VnextPolicyRevisions {
+export interface KxmPolicyRevisions {
   configRevision: string;
   memoryRevision: string;
   executorPolicyRevision: string;
   toolPolicyRevision: string;
 }
 
-export interface VnextMemoryRevisionOptions {
+export interface KxmMemoryRevisionOptions {
   promotedState?: readonly ContextItem[];
   memoryDir?: string;
   skillsDir?: string;
@@ -65,7 +65,7 @@ function objectValue(value: JsonValue | undefined): JsonObject | undefined {
 }
 
 /** Executor policy: the union of executor identities referenced anywhere in the bundle. */
-export function vnextExecutorPolicyRevision(bundle: VnextProjectBundle): string {
+export function kxmExecutorPolicyRevision(bundle: KxmProjectBundle): string {
   const executors = new Set<string>();
   const defaultExecutor = bundle.project.value.defaultExecutor;
   if (typeof defaultExecutor === "string") executors.add(defaultExecutor);
@@ -73,11 +73,11 @@ export function vnextExecutorPolicyRevision(bundle: VnextProjectBundle): string
     const executor = agent.value.executor;
     if (typeof executor === "string") executors.add(executor);
   }
-  return sha256Of(vnextCanonicalJson([...executors].sort() as JsonValue));
+  return sha256Of(kxmCanonicalJson([...executors].sort() as JsonValue));
 }
 
 /** Tool policy: canonical agent/step tool ceilings across the bundle. */
-export function vnextToolPolicyRevision(bundle: VnextProjectBundle): string {
+export function kxmToolPolicyRevision(bundle: KxmProjectBundle): string {
   const policies: JsonObject[] = [];
   for (const agent of [...bundle.agents.values()].sort((left, right) => String(left.id).localeCompare(String(right.id)))) {
     policies.push({ agent: agent.id ?? "unknown", tools: (objectValue(agent.value.tools) ?? null) as JsonValue });
@@ -91,7 +91,7 @@ export function vnextToolPolicyRevision(bundle: VnextProjectBundle): string {
       }
     }
   }
-  return sha256Of(vnextCanonicalJson({ policies, gateRegistry: bundle.gateRegistry?.value ?? null }));
+  return sha256Of(kxmCanonicalJson({ policies, gateRegistry: bundle.gateRegistry?.value ?? null }));
 }
 
 function collectMemoryFiles(dir: string, baseDir: string, ignoreSubdirs: Set<string> = new Set()): { relPath: string; fullPath: string }[] {
@@ -116,9 +116,9 @@ function collectMemoryFiles(dir: string, baseDir: string, ignoreSubdirs: Set<str
  * Git-authored set (.kxm/memory, excluding candidates; .kxm/skills/promoted) plus
  * the promoted-state snapshot.
  */
-export function computeVnextMemoryRevision(
-  bundle: VnextProjectBundle,
-  options: VnextMemoryRevisionOptions = {},
+export function computeKxmMemoryRevision(
+  bundle: KxmProjectBundle,
+  options: KxmMemoryRevisionOptions = {},
 ): string {
   const hash = createHash("sha256");
 
@@ -151,7 +151,7 @@ export function computeVnextMemoryRevision(
       .sort((left, right) => compareCodeUnits(left.id, right.id));
     for (const item of currentItems) {
       hash.update(`state:${item.id}\0`, "utf8");
-      hash.update(vnextCanonicalJson(item as unknown as JsonValue), "utf8");
+      hash.update(kxmCanonicalJson(item as unknown as JsonValue), "utf8");
       hash.update("\0", "utf8");
     }
   }
@@ -161,10 +161,10 @@ export function computeVnextMemoryRevision(
 
 export function checkMemoryRevisionDrift(
   pinnedRevision: string,
-  bundle: VnextProjectBundle,
-  options?: VnextMemoryRevisionOptions,
+  bundle: KxmProjectBundle,
+  options?: KxmMemoryRevisionOptions,
 ): { drifted: boolean; currentRevision: string; pinnedRevision: string } {
-  const currentRevision = computeVnextMemoryRevision(bundle, options);
+  const currentRevision = computeKxmMemoryRevision(bundle, options);
   return {
     drifted: currentRevision !== pinnedRevision,
     currentRevision,
@@ -172,30 +172,30 @@ export function checkMemoryRevisionDrift(
   };
 }
 
-export function vnextPolicyRevisions(
-  bundle: VnextProjectBundle,
-  options?: VnextMemoryRevisionOptions,
-): VnextPolicyRevisions {
+export function kxmPolicyRevisions(
+  bundle: KxmProjectBundle,
+  options?: KxmMemoryRevisionOptions,
+): KxmPolicyRevisions {
   return {
     configRevision: bundle.configRevision,
-    memoryRevision: computeVnextMemoryRevision(bundle, options),
-    executorPolicyRevision: vnextExecutorPolicyRevision(bundle),
-    toolPolicyRevision: vnextToolPolicyRevision(bundle),
+    memoryRevision: computeKxmMemoryRevision(bundle, options),
+    executorPolicyRevision: kxmExecutorPolicyRevision(bundle),
+    toolPolicyRevision: kxmToolPolicyRevision(bundle),
   };
 }
 
-export function vnextDeclaredRepositoryIds(bundle: VnextProjectBundle): string[] {
+export function kxmDeclaredRepositoryIds(bundle: KxmProjectBundle): string[] {
   return [...bundle.repositories.keys()].sort();
 }
 
-export function vnextDeclaredExecutorIds(bundle: VnextProjectBundle): string[] {
+export function kxmDeclaredExecutorIds(bundle: KxmProjectBundle): string[] {
   return [...new Set([
     typeof bundle.project.value.defaultExecutor === "string" ? bundle.project.value.defaultExecutor : undefined,
     ...[...bundle.agents.values()].map((agent) => agent.value.executor).filter((value): value is string => typeof value === "string"),
   ].filter((value): value is string => value !== undefined))].sort();
 }
 
-export function vnextProjectAdmissionLimits(bundle: VnextProjectBundle): {
+export function kxmProjectAdmissionLimits(bundle: KxmProjectBundle): {
   maxConcurrentRuns: number;
   maxRunDurationMs?: number;
   maxAgentTimeMs?: number;
@@ -215,35 +215,35 @@ export function vnextProjectAdmissionLimits(bundle: VnextProjectBundle): {
  * Run acceptance and lifecycle
  * ------------------------------------------------------------------ */
 
-export interface VnextRunAcceptanceRequest {
+export interface KxmRunAcceptanceRequest {
   commandId?: string;
   workflowId: string;
   prompt: string;
 }
 
-export interface VnextRunAcceptance {
+export interface KxmRunAcceptance {
   accepted: boolean;
   idempotent: boolean;
-  run: VnextRunRecord;
-  event: VnextRunEvent;
+  run: KxmRunRecord;
+  event: KxmRunEvent;
 }
 
-export interface VnextRuntimeContext {
-  registry: VnextRuntimeRegistry;
+export interface KxmRuntimeContext {
+  registry: KxmRuntimeRegistry;
   projectRoot: string;
   projectId: string;
   homeRuntimeId: string;
-  eventStore: VnextRunEventStore;
+  eventStore: KxmRunEventStore;
 }
 
-const closedRuntimeContexts = new WeakSet<VnextRuntimeContext>();
-const runtimeCloseHooks = new WeakMap<VnextRuntimeContext, Set<() => void>>();
+const closedRuntimeContexts = new WeakSet<KxmRuntimeContext>();
+const runtimeCloseHooks = new WeakMap<KxmRuntimeContext, Set<() => void>>();
 
-export function isVnextRuntimeContextClosed(context: VnextRuntimeContext): boolean {
+export function isKxmRuntimeContextClosed(context: KxmRuntimeContext): boolean {
   return closedRuntimeContexts.has(context);
 }
 
-export function registerVnextRuntimeCloseHook(context: VnextRuntimeContext, hook: () => void): () => void {
+export function registerKxmRuntimeCloseHook(context: KxmRuntimeContext, hook: () => void): () => void {
   if (closedRuntimeContexts.has(context)) {
     hook();
     return () => undefined;
@@ -265,14 +265,14 @@ export function registerVnextRuntimeCloseHook(context: VnextRuntimeContext, hook
  * active runtime id; direct callers must supply one explicitly. An existing
  * registration always wins and is revalidated immutably.
  */
-export function openVnextRuntimeContext(
+export function openKxmRuntimeContext(
   projectRoot: string,
-  options: VnextConfigOptions & { stateRoot?: string; now?: string; homeRuntimeId: string },
-): VnextRuntimeContext {
-  const paths = vnextRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : {});
-  const registry = new VnextRuntimeRegistry(paths.registryDb);
+  options: KxmConfigOptions & { stateRoot?: string; now?: string; homeRuntimeId: string },
+): KxmRuntimeContext {
+  const paths = kxmRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : {});
+  const registry = new KxmRuntimeRegistry(paths.registryDb);
   try {
-    const bundle = loadVnextProject(projectRoot, options);
+    const bundle = loadKxmProject(projectRoot, options);
     const projectId = String(bundle.project.value.id);
     const registration = registry.registerProject({
       projectId,
@@ -281,8 +281,8 @@ export function openVnextRuntimeContext(
       configRevision: bundle.configRevision,
       now: options.now ?? new Date().toISOString(),
     });
-    const eventStore = new VnextRunEventStore(join(paths.projectsDir, registration.projectKey, "run-events.db"));
-    registerVnextRuntimeHandle(eventStore.path);
+    const eventStore = new KxmRunEventStore(join(paths.projectsDir, registration.projectKey, "run-events.db"));
+    registerKxmRuntimeHandle(eventStore.path);
     return {
       registry,
       projectRoot: bundle.projectRoot,
@@ -296,7 +296,7 @@ export function openVnextRuntimeContext(
   }
 }
 
-export function closeVnextRuntimeContext(context: VnextRuntimeContext): void {
+export function closeKxmRuntimeContext(context: KxmRuntimeContext): void {
   if (closedRuntimeContexts.has(context)) return;
   closedRuntimeContexts.add(context);
   const hooks = runtimeCloseHooks.get(context);
@@ -310,7 +310,7 @@ export function closeVnextRuntimeContext(context: VnextRuntimeContext): void {
       }
     }
   }
-  unregisterVnextRuntimeHandle(context.eventStore.path);
+  unregisterKxmRuntimeHandle(context.eventStore.path);
   context.eventStore.close();
   context.registry.close();
 }
@@ -318,17 +318,17 @@ export function closeVnextRuntimeContext(context: VnextRuntimeContext): void {
 const RUNTIME_EPOCH_NS = process.hrtime.bigint();
 
 /** Intra-process monotonic nanoseconds as a decimal string, ordered only by sequence. */
-export function vnextMonotonicNs(): string {
+export function kxmMonotonicNs(): string {
   return (process.hrtime.bigint() - RUNTIME_EPOCH_NS).toString();
 }
 
-export function vnextIncrementMonotonicNs(value: string): string {
+export function kxmIncrementMonotonicNs(value: string): string {
   return (BigInt(value) + 1n).toString();
 }
 
-export function vnextEventBase(context: VnextRuntimeContext, run: VnextRunRecord, now: string, monotonicNs: string, commandId?: string): Omit<VnextRunEvent, "eventId" | "eventType" | "sequence" | "payload"> {
+export function kxmEventBase(context: KxmRuntimeContext, run: KxmRunRecord, now: string, monotonicNs: string, commandId?: string): Omit<KxmRunEvent, "eventId" | "eventType" | "sequence" | "payload"> {
   return {
-    schema: VNEXT_RUN_EVENT_SCHEMA,
+    schema: KXM_RUN_EVENT_SCHEMA,
     projectId: context.projectId,
     runId: run.runId,
     homeRuntimeId: run.homeRuntimeId,
@@ -343,7 +343,7 @@ export function vnextEventBase(context: VnextRuntimeContext, run: VnextRunRecord
   };
 }
 
-export interface VnextRunAcceptanceOptions {
+export interface KxmRunAcceptanceOptions {
   now?: string;
   monotonicNs?: string;
   memoryRevision?: string;
@@ -353,21 +353,21 @@ export interface VnextRunAcceptanceOptions {
 }
 
 /** Accept a run idempotently: a repeated commandId returns the prior acceptance. */
-export function acceptVnextRun(
-  context: VnextRuntimeContext,
-  bundle: VnextProjectBundle,
-  request: VnextRunAcceptanceRequest,
-  options: VnextRunAcceptanceOptions = {},
-): VnextRunAcceptance {
-  const commandId = request.commandId ?? newVnextCommandId();
+export function acceptKxmRun(
+  context: KxmRuntimeContext,
+  bundle: KxmProjectBundle,
+  request: KxmRunAcceptanceRequest,
+  options: KxmRunAcceptanceOptions = {},
+): KxmRunAcceptance {
+  const commandId = request.commandId ?? newKxmCommandId();
   const now = options.now ?? new Date().toISOString();
-  const monotonicNs = options.monotonicNs ?? vnextMonotonicNs();
+  const monotonicNs = options.monotonicNs ?? kxmMonotonicNs();
 
   const workflow = bundle.workflows.get(request.workflowId);
   if (!workflow) {
     throw runtimeError("run_workflow_unknown", ".kxm/workflows", `workflow ${request.workflowId} does not exist in this project`);
   }
-  const revisions = vnextPolicyRevisions(bundle, options);
+  const revisions = kxmPolicyRevisions(bundle, options);
   const memoryRevision = options.memoryRevision ?? revisions.memoryRevision;
   const promptSha256 = `sha256:${createHash("sha256").update(request.prompt, "utf8").digest("hex")}`;
 
@@ -387,17 +387,17 @@ export function acceptVnextRun(
       return { accepted: true, idempotent: true, run, event: events[0]! };
     }
 
-    const runId = newVnextRunId();
+    const runId = newKxmRunId();
     const payload: Record<string, unknown> = {
       workflowId: request.workflowId,
       status: "created",
       promptHash: promptSha256,
-      repositoryIds: vnextDeclaredRepositoryIds(bundle),
-      executorIds: vnextDeclaredExecutorIds(bundle),
+      repositoryIds: kxmDeclaredRepositoryIds(bundle),
+      executorIds: kxmDeclaredExecutorIds(bundle),
     };
-    const event: VnextRunEvent = {
-      schema: VNEXT_RUN_EVENT_SCHEMA,
-      eventId: newVnextEventId(),
+    const event: KxmRunEvent = {
+      schema: KXM_RUN_EVENT_SCHEMA,
+      eventId: newKxmEventId(),
       eventType: "run.created",
       projectId: context.projectId,
       runId,
@@ -413,7 +413,7 @@ export function acceptVnextRun(
       toolPolicyRevision: revisions.toolPolicyRevision,
       payload,
     };
-    const run: VnextRunRecord = {
+    const run: KxmRunRecord = {
       runId,
       projectId: context.projectId,
       homeRuntimeId: context.homeRuntimeId,
@@ -445,14 +445,14 @@ export function acceptVnextRun(
  * Projection
  * ------------------------------------------------------------------ */
 
-export function foldStoredVnextRun(context: VnextRuntimeContext, run: VnextRunRecord): VnextRunState {
+export function foldStoredKxmRun(context: KxmRuntimeContext, run: KxmRunRecord): KxmRunState {
   const events = context.eventStore.events(run.runId, 0, 1_000_000);
   const planRow = context.eventStore.runPlan(run.runId);
   if (!planRow && events.some((event) => event.eventType.startsWith("step.") || event.eventType.startsWith("effect.") || event.payload.status === "preparing" || event.payload.status === "running" || event.payload.status === "cancelling")) {
     throw runtimeError("run_plan_missing", run.runId, "run reached preparing or later without a pinned plan");
   }
-  const envelope = planRow ? loadVnextRunPlanEnvelope(context.eventStore, run) : undefined;
-  const state = foldVnextRunState(run, envelope?.plan, events, envelope
+  const envelope = planRow ? loadKxmRunPlanEnvelope(context.eventStore, run) : undefined;
+  const state = foldKxmRunState(run, envelope?.plan, events, envelope
     ? {
       observationLookup: (attemptId, observationId) => {
         const row = context.eventStore.gateObservationForAttempt(attemptId);
@@ -467,7 +467,7 @@ export function foldStoredVnextRun(context: VnextRuntimeContext, run: VnextRunRe
       projectLimits: envelope.projectLimits,
     }
     : {});
-  if (envelope) verifyVnextGateEvidence(context.eventStore, run, envelope, events, state);
+  if (envelope) verifyKxmGateEvidence(context.eventStore, run, envelope, events, state);
   assertStoredProjection(context, run);
   return state;
 }
@@ -481,22 +481,22 @@ function storedProjectionSchema(stateJson: string): string | undefined {
   }
 }
 
-function assertStoredProjection(context: VnextRuntimeContext, run: VnextRunRecord): void {
+function assertStoredProjection(context: KxmRuntimeContext, run: KxmRunRecord): void {
   const stored = context.eventStore.runState(run.runId);
   if (!stored) return;
   const schema = storedProjectionSchema(stored.state);
-  if (schema !== VNEXT_RUN_STATE_SCHEMA) {
+  if (schema !== KXM_RUN_STATE_SCHEMA) {
     throw runtimeError("run_projection_divergent", run.runId, "stored run_state does not match the folded projection");
   }
 }
 
 /** Fold a stored run into its current status with evidence verification. */
-export function readVnextRunStatus(context: VnextRuntimeContext, run: VnextRunRecord): VnextRunStatus {
-  return foldStoredVnextRun(context, run).status;
+export function readKxmRunStatus(context: KxmRuntimeContext, run: KxmRunRecord): KxmRunStatus {
+  return foldStoredKxmRun(context, run).status;
 }
 
-function persistProjection(context: VnextRuntimeContext, run: VnextRunRecord, state: VnextRunState, now: string): VnextRunRecord {
-  const canonical = vnextCanonicalJson(state as unknown as JsonValue);
+function persistProjection(context: KxmRuntimeContext, run: KxmRunRecord, state: KxmRunState, now: string): KxmRunRecord {
+  const canonical = kxmCanonicalJson(state as unknown as JsonValue);
   const stored = context.eventStore.runState(run.runId);
   if (stored && stored.state !== canonical) {
     throw runtimeError("run_projection_divergent", run.runId, "stored run_state does not match the folded projection");
@@ -514,10 +514,10 @@ function persistProjection(context: VnextRuntimeContext, run: VnextRunRecord, st
 }
 
 /** Rebuild the stored run row from the event log; returns the projected record. */
-export function rebuildVnextRunProjection(context: VnextRuntimeContext, runId: string): VnextRunRecord {
+export function rebuildKxmRunProjection(context: KxmRuntimeContext, runId: string): KxmRunRecord {
   const stored = context.eventStore.run(runId);
   if (!stored) throw runtimeError("run_unknown", runId, "run does not exist in this event store");
-  const state = foldStoredVnextRun(context, stored);
+  const state = foldStoredKxmRun(context, stored);
   const events = context.eventStore.events(runId, 0, 1_000_000);
   if (events.length === 0) throw runtimeError("run_events_corrupt", runId, "run has no events");
   const last = events[events.length - 1]!;
@@ -528,28 +528,28 @@ export function rebuildVnextRunProjection(context: VnextRuntimeContext, runId: s
  * persisting. GET paths must not write (no run_state upsert, no status
  * update, no run_projection_divergent throw) — the event log stays the sole
  * source of truth and the folded status is returned as-is. */
-export function projectVnextRunReadOnly(context: VnextRuntimeContext, runId: string): VnextRunRecord {
+export function projectKxmRunReadOnly(context: KxmRuntimeContext, runId: string): KxmRunRecord {
   const stored = context.eventStore.run(runId);
   if (!stored) throw runtimeError("run_unknown", runId, "run does not exist in this event store");
-  const state = foldStoredVnextRun(context, stored);
+  const state = foldStoredKxmRun(context, stored);
   const events = context.eventStore.events(runId, 0, 1_000_000);
   if (events.length === 0) throw runtimeError("run_events_corrupt", runId, "run has no events");
   const last = events[events.length - 1]!;
   return { ...stored, status: state.status, updatedAt: last.occurredAt };
 }
 
-export function persistVnextRunState(context: VnextRuntimeContext, runId: string, state: VnextRunState, lastSequence: number): void {
+export function persistKxmRunState(context: KxmRuntimeContext, runId: string, state: KxmRunState, lastSequence: number): void {
   const stored = context.eventStore.runState(runId);
   if (stored) {
     const schema = storedProjectionSchema(stored.state);
-    if (schema !== VNEXT_RUN_STATE_SCHEMA) {
+    if (schema !== KXM_RUN_STATE_SCHEMA) {
       throw runtimeError("run_projection_divergent", runId, "stored run_state does not match the folded projection");
     }
   }
   context.eventStore.upsertRunState({
     runId,
     lastSequence,
-    state: vnextCanonicalJson(state as unknown as JsonValue),
+    state: kxmCanonicalJson(state as unknown as JsonValue),
   });
 }
 
@@ -557,14 +557,14 @@ export function persistVnextRunState(context: VnextRuntimeContext, runId: string
  * Cancel
  * ------------------------------------------------------------------ */
 
-export interface VnextRunCancelResult {
-  run: VnextRunRecord;
+export interface KxmRunCancelResult {
+  run: KxmRunRecord;
   idempotent: boolean;
-  events: VnextRunEvent[];
+  events: KxmRunEvent[];
 }
 
-export function cancelVnextRun(
-  context: VnextRuntimeContext,
+export function cancelKxmRun(
+  context: KxmRuntimeContext,
   runId: string,
   options: {
     commandId?: string;
@@ -573,10 +573,10 @@ export function cancelVnextRun(
     reason?: string;
     budget?: { budgetMs: number; elapsedMs: number; source: "workflow" | "project" | "both" };
   } = {},
-): VnextRunCancelResult {
-  const commandId = options.commandId ?? newVnextCommandId();
+): KxmRunCancelResult {
+  const commandId = options.commandId ?? newKxmCommandId();
   const now = options.now ?? new Date().toISOString();
-  const monotonicNs = options.monotonicNs ?? vnextMonotonicNs();
+  const monotonicNs = options.monotonicNs ?? kxmMonotonicNs();
   const abortControllers: AbortController[] = [];
 
   const result = context.eventStore.transaction(() => {
@@ -587,11 +587,11 @@ export function cancelVnextRun(
       }
       const run = context.eventStore.run(prior.runId);
       if (!run) throw runtimeError("run_command_corrupt", commandId, "idempotent command references a missing run");
-      return { run, idempotent: true, events: [] as VnextRunEvent[] };
+      return { run, idempotent: true, events: [] as KxmRunEvent[] };
     }
     const run = context.eventStore.run(runId);
     if (!run) throw runtimeError("run_unknown", runId, "run does not exist in this event store");
-    const folded = foldStoredVnextRun(context, run);
+    const folded = foldStoredKxmRun(context, run);
     if (isTerminalRunStatus(folded.status) || folded.status === "cancelling") {
       context.eventStore.insertCommand({
         commandId,
@@ -600,27 +600,27 @@ export function cancelVnextRun(
         result: { runId, status: folded.status },
         recordedAt: now,
       });
-      return { run: { ...run, status: folded.status }, idempotent: true, events: [] as VnextRunEvent[] };
+      return { run: { ...run, status: folded.status }, idempotent: true, events: [] as KxmRunEvent[] };
     }
 
-    const events: VnextRunEvent[] = [];
+    const events: KxmRunEvent[] = [];
     let sequence = context.eventStore.nextSequence(runId);
     let nextMono = monotonicNs;
-    const push = (eventType: string, payload: Record<string, unknown>): VnextRunEvent => {
-      const event: VnextRunEvent = {
-        ...vnextEventBase(context, run, now, nextMono, commandId),
-        eventId: newVnextEventId(),
+    const push = (eventType: string, payload: Record<string, unknown>): KxmRunEvent => {
+      const event: KxmRunEvent = {
+        ...kxmEventBase(context, run, now, nextMono, commandId),
+        eventId: newKxmEventId(),
         eventType,
         sequence: sequence++,
         payload,
       };
-      nextMono = vnextIncrementMonotonicNs(nextMono);
+      nextMono = kxmIncrementMonotonicNs(nextMono);
       events.push(event);
       return event;
     };
 
     const cancelReason = options.reason ?? "operator_cancel";
-    const activeAttempt = Boolean(folded.currentStep?.attemptId) || vnextFoldPanelAttemptIds(folded.currentStep).length > 0;
+    const activeAttempt = Boolean(folded.currentStep?.attemptId) || kxmFoldPanelAttemptIds(folded.currentStep).length > 0;
     const cancelPayload: Record<string, unknown> = {
       actor: { kind: "runtime", id: context.homeRuntimeId },
       reason: cancelReason,
@@ -633,11 +633,11 @@ export function cancelVnextRun(
     }
     push("run.cancel_requested", cancelPayload);
 
-    let status: VnextRunStatus = "cancelled";
+    let status: KxmRunStatus = "cancelled";
     if (folded.status === "running" && activeAttempt) {
       status = "cancelling";
       push("run.status_changed", { status: "cancelling", reason: cancelReason });
-      const attemptIds = new Set(vnextFoldPanelAttemptIds(folded.currentStep));
+      const attemptIds = new Set(kxmFoldPanelAttemptIds(folded.currentStep));
       if (folded.currentStep?.attemptId) attemptIds.add(folded.currentStep.attemptId);
       for (const attemptId of attemptIds) {
         const capability = context.eventStore.capabilityByAttempt(attemptId);
@@ -645,7 +645,7 @@ export function cancelVnextRun(
           context.eventStore.settleCapability(attemptId, "revoked");
         }
       }
-      for (const owned of vnextAttemptControllers(context.eventStore.path, runId)) {
+      for (const owned of kxmAttemptControllers(context.eventStore.path, runId)) {
         abortControllers.push(owned.controller);
       }
     } else if (folded.status === "blocked_uncertain") {
@@ -656,9 +656,9 @@ export function cancelVnextRun(
         if (capability && (capability.state === "issued" || capability.state === "revoked")) {
           context.eventStore.settleCapability(attemptId, "revoked");
         }
-        resolveVnextGateHold(context.eventStore.path, runId, attemptId);
+        resolveKxmGateHold(context.eventStore.path, runId, attemptId);
       }
-      for (const owned of vnextAttemptControllers(context.eventStore.path, runId)) {
+      for (const owned of kxmAttemptControllers(context.eventStore.path, runId)) {
         abortControllers.push(owned.controller);
       }
       push("run.status_changed", { status: "cancelled", reason: cancelReason });
@@ -671,8 +671,8 @@ export function cancelVnextRun(
     }
 
     for (const event of events) context.eventStore.appendEvent(event);
-    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, status, now);
     context.eventStore.insertCommand({
       commandId,
@@ -693,7 +693,7 @@ export function cancelVnextRun(
  * ------------------------------------------------------------------ */
 
 /** Runs pin revisions at acceptance; drift is reported, never silently adopted. */
-export function vnextRunRevisionDrift(run: VnextRunRecord, bundle: VnextProjectBundle): { configDrift: boolean; currentRevision: string; pinnedRevision: string } {
+export function kxmRunRevisionDrift(run: KxmRunRecord, bundle: KxmProjectBundle): { configDrift: boolean; currentRevision: string; pinnedRevision: string } {
   return {
     configDrift: run.configRevision !== bundle.configRevision,
     currentRevision: bundle.configRevision,
@@ -701,6 +701,6 @@ export function vnextRunRevisionDrift(run: VnextRunRecord, bundle: VnextProjectB
   };
 }
 
-export function assertVnextConfigError(error: unknown): asserts error is VnextConfigError {
-  if (!(error instanceof VnextConfigError)) throw error;
+export function assertKxmConfigError(error: unknown): asserts error is KxmConfigError {
+  if (!(error instanceof KxmConfigError)) throw error;
 }