@kontextmind/kxm 0.7.39 → 0.7.43

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

@@ -2,24 +2,24 @@ import { createHash, randomUUID } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { DatabaseSync } from "./sqlite.ts";
-import { VnextConfigError, validateDriveReceipt, validateRunEvent, vnextCanonicalJson, type JsonValue, type VnextConfigIssue, type VnextConfigOptions } from "./vnext-config.ts";
-import { vnextUserStateRoot } from "./vnext-bindings.ts";
+import { KxmConfigError, validateDriveReceipt, validateRunEvent, kxmCanonicalJson, type JsonValue, type KxmConfigIssue, type KxmConfigOptions } from "./project-config.ts";
+import { kxmUserStateRoot } from "./bindings.ts";
 
 /* ------------------------------------------------------------------ *
  * Runtime registry (per-user, platform state root)
  * ------------------------------------------------------------------ */
 
-export interface VnextRuntimePaths {
+export interface KxmRuntimePaths {
   stateRoot: string;
   runtimeDir: string;
   registryDb: string;
   projectsDir: string;
 }
 
-export function vnextRuntimePaths(options: { stateRoot?: string; env?: NodeJS.ProcessEnv; homeDir?: string } = {}): VnextRuntimePaths {
+export function kxmRuntimePaths(options: { stateRoot?: string; env?: NodeJS.ProcessEnv; homeDir?: string } = {}): KxmRuntimePaths {
   const stateRoot = options.stateRoot
     ? resolve(options.stateRoot)
-    : vnextUserStateRoot({ ...(options.env ? { env: options.env } : {}), ...(options.homeDir ? { homeDir: options.homeDir } : {}) });
+    : kxmUserStateRoot({ ...(options.env ? { env: options.env } : {}), ...(options.homeDir ? { homeDir: options.homeDir } : {}) });
   const runtimeDir = join(stateRoot, "runtime");
   return {
     stateRoot,
@@ -29,12 +29,12 @@ export function vnextRuntimePaths(options: { stateRoot?: string; env?: NodeJS.Pr
   };
 }
 
-function runtimeIssue(phase: VnextConfigIssue["phase"], code: string, file: string, message: string): VnextConfigIssue {
+function runtimeIssue(phase: KxmConfigIssue["phase"], code: string, file: string, message: string): KxmConfigIssue {
   return { phase, code, file, message };
 }
 
-export function runtimeError(code: string, file: string, message: string): VnextConfigError {
-  return new VnextConfigError([runtimeIssue("semantic", code, file, message)]);
+export function runtimeError(code: string, file: string, message: string): KxmConfigError {
+  return new KxmConfigError([runtimeIssue("semantic", code, file, message)]);
 }
 
 export function projectRuntimeKey(projectRoot: string): string {
@@ -65,12 +65,12 @@ import {
   type DatabaseSchemaSpec,
 } from "./database.ts";
 
-export type VnextDatabaseSchema = DatabaseSchemaSpec;
+export type KxmDatabaseSchema = DatabaseSchemaSpec;
 export { openDatabase };
 
 /* ----------------------------- registry ---------------------------- */
 
-export interface VnextSupervisorRecord {
+export interface KxmSupervisorRecord {
   runtimeId: string;
   pid: number;
   port: number;
@@ -80,7 +80,7 @@ export interface VnextSupervisorRecord {
   state: "starting" | "running" | "stopping" | "stopped";
 }
 
-export interface VnextProjectRegistration {
+export interface KxmProjectRegistration {
   projectId: string;
   projectRoot: string;
   projectKey: string;
@@ -89,7 +89,7 @@ export interface VnextProjectRegistration {
   registeredAt: string;
 }
 
-export const VNEXT_REGISTRY_SCHEMA_VERSION = 1;
+export const KXM_REGISTRY_SCHEMA_VERSION = 1;
 
 const REGISTRY_TABLES = {
   supervisor: ["singleton_id", "runtime_id", "pid", "port", "token_hash", "started_at", "heartbeat_at", "state"],
@@ -117,7 +117,7 @@ CREATE TABLE projects (
 ) STRICT;
 `;
 
-export class VnextRuntimeRegistry {
+export class KxmRuntimeRegistry {
   readonly path: string;
   private readonly database: DatabaseSync;
 
@@ -125,7 +125,7 @@ export class VnextRuntimeRegistry {
     this.path = resolve(path);
     this.database = openDatabase(this.path, "runtime registry", {
       schema: REGISTRY_SCHEMA,
-      version: VNEXT_REGISTRY_SCHEMA_VERSION,
+      version: KXM_REGISTRY_SCHEMA_VERSION,
       tables: REGISTRY_TABLES,
     });
   }
@@ -135,7 +135,7 @@ export class VnextRuntimeRegistry {
   }
 
   /** Atomically claim or refresh the supervisor singleton. Returns the record that now owns it. */
-  claimSupervisor(record: { runtimeId: string; pid: number; port: number; tokenHash: string; now: string }): { claimed: boolean; record: VnextSupervisorRecord } {
+  claimSupervisor(record: { runtimeId: string; pid: number; port: number; tokenHash: string; now: string }): { claimed: boolean; record: KxmSupervisorRecord } {
     this.database.exec("BEGIN IMMEDIATE");
     try {
       const existing = this.readSupervisorRow();
@@ -161,7 +161,7 @@ export class VnextRuntimeRegistry {
   }
 
   /** Take over a dead supervisor's singleton, preserving its logical runtime identity and project home bindings. */
-  takeoverSupervisor(record: { runtimeId: string; pid: number; port: number; tokenHash: string; now: string; observedDeadPid: number; observedHeartbeatAt: string }): VnextSupervisorRecord {
+  takeoverSupervisor(record: { runtimeId: string; pid: number; port: number; tokenHash: string; now: string; observedDeadPid: number; observedHeartbeatAt: string }): KxmSupervisorRecord {
     this.database.exec("BEGIN IMMEDIATE");
     try {
       // The logical runtime id is stable across process restarts: the new
@@ -203,9 +203,9 @@ export class VnextRuntimeRegistry {
     return Number(result.changes);
   }
 
-  private readSupervisorRow(): VnextSupervisorRecord | undefined {
+  private readSupervisorRow(): KxmSupervisorRecord | undefined {
     const row = this.database.prepare("SELECT runtime_id, pid, port, token_hash, started_at, heartbeat_at, state FROM supervisor WHERE singleton_id = 1").get() as
-      | { runtime_id: string; pid: number; port: number; token_hash: string; started_at: string; heartbeat_at: string; state: VnextSupervisorRecord["state"] }
+      | { runtime_id: string; pid: number; port: number; token_hash: string; started_at: string; heartbeat_at: string; state: KxmSupervisorRecord["state"] }
       | undefined;
     return row
       ? {
@@ -220,12 +220,12 @@ export class VnextRuntimeRegistry {
       : undefined;
   }
 
-  supervisor(): VnextSupervisorRecord | undefined {
+  supervisor(): KxmSupervisorRecord | undefined {
     return this.readSupervisorRow();
   }
 
   /** Register or revalidate a project's home binding. Home Runtime is immutable. */
-  registerProject(registration: { projectId: string; projectRoot: string; homeRuntimeId: string; configRevision?: string; now: string }): VnextProjectRegistration {
+  registerProject(registration: { projectId: string; projectRoot: string; homeRuntimeId: string; configRevision?: string; now: string }): KxmProjectRegistration {
     const projectRoot = resolve(registration.projectRoot);
     const projectKey = projectRuntimeKey(projectRoot);
     this.database.exec("BEGIN IMMEDIATE");
@@ -246,7 +246,7 @@ export class VnextRuntimeRegistry {
           this.database.exec("ROLLBACK");
           throw runtimeError("project_home_conflict", ".kxm/project.yaml", problems.join("; "));
         }
-        const result: VnextProjectRegistration = {
+        const result: KxmProjectRegistration = {
           projectId: existing.project_id,
           projectRoot: existing.project_root,
           projectKey: existing.project_key,
@@ -276,7 +276,7 @@ export class VnextRuntimeRegistry {
     }
   }
 
-  project(projectId: string): VnextProjectRegistration | undefined {
+  project(projectId: string): KxmProjectRegistration | undefined {
     const row = this.database.prepare("SELECT project_id, project_root, project_key, home_runtime_id, config_revision, registered_at FROM projects WHERE project_id = ?").get(projectId) as
       | { project_id: string; project_root: string; project_key: string; home_runtime_id: string; config_revision: string | null; registered_at: string }
       | undefined;
@@ -292,7 +292,7 @@ export class VnextRuntimeRegistry {
       : undefined;
   }
 
-  projectByRoot(projectRoot: string): VnextProjectRegistration | undefined {
+  projectByRoot(projectRoot: string): KxmProjectRegistration | undefined {
     const key = projectRuntimeKey(projectRoot);
     const row = this.database.prepare("SELECT project_id, project_root, project_key, home_runtime_id, config_revision, registered_at FROM projects WHERE project_key = ?").get(key) as
       | { project_id: string; project_root: string; project_key: string; home_runtime_id: string; config_revision: string | null; registered_at: string }
@@ -312,18 +312,18 @@ export class VnextRuntimeRegistry {
 
 /* --------------------------- event store --------------------------- */
 
-export type VnextRunStatus = "created" | "preparing" | "running" | "waiting" | "blocked_uncertain" | "cancelling" | "cancelled" | "completed" | "failed";
+export type KxmRunStatus = "created" | "preparing" | "running" | "waiting" | "blocked_uncertain" | "cancelling" | "cancelled" | "completed" | "failed";
 
-export const VNEXT_RUN_EVENT_SCHEMA = "kxm.run-event.v1";
-export const VNEXT_ABSENT_MEMORY_REVISION = "ctxrev_absent";
+export const KXM_RUN_EVENT_SCHEMA = "kxm.run-event.v1";
+export const KXM_ABSENT_MEMORY_REVISION = "ctxrev_absent";
 
-export interface VnextRunRecord {
+export interface KxmRunRecord {
   runId: string;
   projectId: string;
   homeRuntimeId: string;
   workflowId: string;
   promptSha256: string;
-  status: VnextRunStatus;
+  status: KxmRunStatus;
   configRevision: string;
   memoryRevision: string;
   executorPolicyRevision: string;
@@ -332,8 +332,8 @@ export interface VnextRunRecord {
   updatedAt: string;
 }
 
-export interface VnextRunEvent {
-  schema: typeof VNEXT_RUN_EVENT_SCHEMA;
+export interface KxmRunEvent {
+  schema: typeof KXM_RUN_EVENT_SCHEMA;
   eventId: string;
   eventType: string;
   projectId: string;
@@ -351,36 +351,36 @@ export interface VnextRunEvent {
   payload: Record<string, unknown>;
 }
 
-export interface VnextRunPlanRow {
+export interface KxmRunPlanRow {
   runId: string;
   runPlanHash: string;
   envelope: string;
   pinnedSequence: number;
 }
 
-export interface VnextRunStateRow {
+export interface KxmRunStateRow {
   runId: string;
   lastSequence: number;
   state: string;
 }
 
-export interface VnextDriveReceiptHandoff {
+export interface KxmDriveReceiptHandoff {
   reason: string;
   field?: string;
   stepId?: string;
   detail: string;
 }
 
-export interface VnextDriveReceiptSettlement {
+export interface KxmDriveReceiptSettlement {
   kind: "terminal" | "handoff" | "unsettled";
   status: string;
   reason: string;
-  handoff?: VnextDriveReceiptHandoff;
+  handoff?: KxmDriveReceiptHandoff;
   error?: { class: string; component: string; retryable: boolean };
 }
 
-export interface VnextDriveReceipt {
-  schema: typeof VNEXT_DRIVE_RECEIPT_SCHEMA;
+export interface KxmDriveReceipt {
+  schema: typeof KXM_DRIVE_RECEIPT_SCHEMA;
   driveId: string;
   runId: string;
   projectId: string;
@@ -391,16 +391,16 @@ export interface VnextDriveReceipt {
   closedAt: string;
   lastSequence: number;
   logHash: string;
-  settlement: VnextDriveReceiptSettlement;
-  budget: VnextDriveReceiptBudget | null;
+  settlement: KxmDriveReceiptSettlement;
+  budget: KxmDriveReceiptBudget | null;
   producer: { id: string; closed: boolean };
 }
 
-export type VnextDriveReceiptListItem =
-  | VnextDriveReceipt
+export type KxmDriveReceiptListItem =
+  | KxmDriveReceipt
   | { readonly driveId: string; readonly divergence: string };
 
-export interface VnextDriveReceiptBudget {
+export interface KxmDriveReceiptBudget {
   budgetMs: number;
   source: "workflow" | "project" | "both";
   elapsedMs: number;
@@ -408,14 +408,14 @@ export interface VnextDriveReceiptBudget {
 }
 
 /** sha256 over `eventId:sequence` for events 1..lastSequence, in sequence order. */
-export function hashVnextDriveLog(events: readonly { eventId: string; sequence: number }[]): string {
+export function hashKxmDriveLog(events: readonly { eventId: string; sequence: number }[]): string {
   const body = events.map((event) => `${event.eventId}:${event.sequence}`).join("\n");
   return `sha256:${createHash("sha256").update(body, "utf8").digest("hex")}`;
 }
 
-export function verifyVnextDriveReceipt(
-  receipt: VnextDriveReceipt,
-  events: readonly VnextRunEvent[],
+export function verifyKxmDriveReceipt(
+  receipt: KxmDriveReceipt,
+  events: readonly KxmRunEvent[],
   foldedStatus: string,
   binding: { runId: string; driveId: string },
 ): { verified: boolean; divergence?: string } {
@@ -432,7 +432,7 @@ export function verifyVnextDriveReceipt(
     reasons.push(`lastSequence ${receipt.lastSequence} != log ${currentLast}`);
   }
   const prefix = events.filter((event) => event.sequence >= 1 && event.sequence <= receipt.lastSequence);
-  if (hashVnextDriveLog(prefix) !== receipt.logHash) {
+  if (hashKxmDriveLog(prefix) !== receipt.logHash) {
     reasons.push("logHash mismatch");
   }
   if (receipt.settlement.status !== foldedStatus) {
@@ -442,7 +442,7 @@ export function verifyVnextDriveReceipt(
   return { verified: false, divergence: reasons.join("; ") };
 }
 
-export interface VnextAttemptCapabilityRow {
+export interface KxmAttemptCapabilityRow {
   attemptId: string;
   runId: string;
   assignmentId: string;
@@ -453,15 +453,15 @@ export interface VnextAttemptCapabilityRow {
   state: "issued" | "settled" | "revoked";
 }
 
-export type VnextGateKind = "command" | "artifacts-exist";
-export type VnextGateExpect = "pass" | "fail";
-export type VnextGateCompleteness = "complete" | "incomplete" | "no-start";
-export type VnextGateStopCause = "none" | "timeout" | "cancel" | "error";
-export type VnextGateSignalsAttempted = "none" | "term" | "term-kill";
-export type VnextGateErrorClass = "validation" | "spawn-error" | "stream-error" | "stop-error" | "recording-error" | "lost-close";
-export type VnextGateEvidenceOutcome = "passed" | "implementation-failure" | "repro-missing";
+export type KxmGateKind = "command" | "artifacts-exist";
+export type KxmGateExpect = "pass" | "fail";
+export type KxmGateCompleteness = "complete" | "incomplete" | "no-start";
+export type KxmGateStopCause = "none" | "timeout" | "cancel" | "error";
+export type KxmGateSignalsAttempted = "none" | "term" | "term-kill";
+export type KxmGateErrorClass = "validation" | "spawn-error" | "stream-error" | "stop-error" | "recording-error" | "lost-close";
+export type KxmGateEvidenceOutcome = "passed" | "implementation-failure" | "repro-missing";
 
-export interface VnextGateAttemptRow {
+export interface KxmGateAttemptRow {
   attemptId: string;
   runId: string;
   projectId: string;
@@ -471,8 +471,8 @@ export interface VnextGateAttemptRow {
   assignmentId: string;
   effectId: string;
   gateId: string;
-  gateKind: VnextGateKind;
-  expect: VnextGateExpect;
+  gateKind: KxmGateKind;
+  expect: KxmGateExpect;
   gateDefinitionHash: string;
   registryHash: string;
   runPlanHash: string;
@@ -482,7 +482,7 @@ export interface VnextGateAttemptRow {
   contentHash: string;
 }
 
-export interface VnextGateObservationRow {
+export interface KxmGateObservationRow {
   observationId: string;
   attemptId: string;
   runId: string;
@@ -492,16 +492,16 @@ export interface VnextGateObservationRow {
   stepAttempt: number;
   assignmentId: string;
   effectId: string;
-  completeness: VnextGateCompleteness;
+  completeness: KxmGateCompleteness;
   spawned: 0 | 1;
   pid: number | null;
   exitCode: number | null;
   signal: string | null;
   exitObserved: 0 | 1;
   closeObserved: 0 | 1;
-  stopCause: VnextGateStopCause;
-  signalsAttempted: VnextGateSignalsAttempted;
-  errorClass: VnextGateErrorClass | null;
+  stopCause: KxmGateStopCause;
+  signalsAttempted: KxmGateSignalsAttempted;
+  errorClass: KxmGateErrorClass | null;
   stdoutSha256: string | null;
   stdoutBytes: number | null;
   stdoutComplete: 0 | 1 | null;
@@ -517,7 +517,7 @@ export interface VnextGateObservationRow {
   contentHash: string;
 }
 
-export interface VnextGateEvidenceRow {
+export interface KxmGateEvidenceRow {
   evidenceId: string;
   attemptId: string;
   observationId: string;
@@ -530,19 +530,19 @@ export interface VnextGateEvidenceRow {
   effectId: string;
   evidenceKey: string | null;
   kind: "gate";
-  expect: VnextGateExpect;
-  outcome: VnextGateEvidenceOutcome;
+  expect: KxmGateExpect;
+  outcome: KxmGateEvidenceOutcome;
   settledEventId: string;
   contentHash: string;
 }
 
-export interface VnextGateRowCounts {
+export interface KxmGateRowCounts {
   attempts: number;
   observations: number;
   evidence: number;
 }
 
-export interface VnextCommandRecord {
+export interface KxmCommandRecord {
   commandId: string;
   runId: string;
   kind: string;
@@ -550,8 +550,8 @@ export interface VnextCommandRecord {
   recordedAt: string;
 }
 
-export const VNEXT_EVENT_STORE_SCHEMA_VERSION = 4;
-export const VNEXT_DRIVE_RECEIPT_SCHEMA = "kxm.drive-receipt.v1";
+export const KXM_EVENT_STORE_SCHEMA_VERSION = 4;
+export const KXM_DRIVE_RECEIPT_SCHEMA = "kxm.drive-receipt.v1";
 export const DRIVE_RECEIPT_MAX_BYTES = 8 * 1024;
 
 const EVENT_STORE_TABLES = {
@@ -757,7 +757,7 @@ const EVENT_STORE_MIGRATIONS = [
   },
 ];
 
-export class VnextRunEventStore {
+export class KxmRunEventStore {
   readonly path: string;
   private readonly database: DatabaseSync;
 
@@ -765,7 +765,7 @@ export class VnextRunEventStore {
     this.path = resolve(path);
     this.database = openDatabase(this.path, "run event store", {
       schema: EVENT_STORE_SCHEMA,
-      version: VNEXT_EVENT_STORE_SCHEMA_VERSION,
+      version: KXM_EVENT_STORE_SCHEMA_VERSION,
       tables: EVENT_STORE_TABLES,
       migrations: EVENT_STORE_MIGRATIONS,
     });
@@ -814,7 +814,7 @@ export class VnextRunEventStore {
     return withDatabaseTransaction(this.database, work);
   }
 
-  command(commandId: string): VnextCommandRecord | undefined {
+  command(commandId: string): KxmCommandRecord | undefined {
     const row = this.database.prepare("SELECT command_id, run_id, kind, result, recorded_at FROM commands WHERE command_id = ?").get(commandId) as
       | { command_id: string; run_id: string; kind: string; result: string; recorded_at: string }
       | undefined;
@@ -823,12 +823,12 @@ export class VnextRunEventStore {
       : undefined;
   }
 
-  insertCommand(record: VnextCommandRecord): void {
+  insertCommand(record: KxmCommandRecord): void {
     this.database.prepare("INSERT INTO commands (command_id, run_id, kind, result, recorded_at) VALUES (?, ?, ?, ?, ?)")
       .run(record.commandId, record.runId, record.kind, JSON.stringify(record.result), record.recordedAt);
   }
 
-  insertRun(record: VnextRunRecord): void {
+  insertRun(record: KxmRunRecord): void {
     this.database.prepare(`
       INSERT INTO runs (run_id, project_id, home_runtime_id, workflow_id, prompt_sha256, status, config_revision, memory_revision, executor_policy_revision, tool_policy_revision, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -848,11 +848,11 @@ export class VnextRunEventStore {
     );
   }
 
-  updateRunStatus(runId: string, status: VnextRunStatus, updatedAt: string): void {
+  updateRunStatus(runId: string, status: KxmRunStatus, updatedAt: string): void {
     this.database.prepare("UPDATE runs SET status = ?, updated_at = ? WHERE run_id = ?").run(status, updatedAt, runId);
   }
 
-  run(runId: string): VnextRunRecord | undefined {
+  run(runId: string): KxmRunRecord | undefined {
     const row = this.database.prepare(`
       SELECT run_id, project_id, home_runtime_id, workflow_id, prompt_sha256, status, config_revision, memory_revision, executor_policy_revision, tool_policy_revision, created_at, updated_at
       FROM runs WHERE run_id = ?
@@ -863,7 +863,7 @@ export class VnextRunEventStore {
         home_runtime_id: string;
         workflow_id: string;
         prompt_sha256: string;
-        status: VnextRunStatus;
+        status: KxmRunStatus;
         config_revision: string;
         memory_revision: string;
         executor_policy_revision: string;
@@ -875,7 +875,7 @@ export class VnextRunEventStore {
     return row ? runFromRow(row) : undefined;
   }
 
-  runsForProject(projectId: string, limit = 50): VnextRunRecord[] {
+  runsForProject(projectId: string, limit = 50): KxmRunRecord[] {
     const rows = this.database.prepare(`
       SELECT run_id, project_id, home_runtime_id, workflow_id, prompt_sha256, status, config_revision, memory_revision, executor_policy_revision, tool_policy_revision, created_at, updated_at
       FROM runs WHERE project_id = ? ORDER BY created_at DESC, run_id DESC LIMIT ?
@@ -888,7 +888,7 @@ export class VnextRunEventStore {
     return row.max_sequence + 1;
   }
 
-  appendEvent(event: VnextRunEvent): void {
+  appendEvent(event: KxmRunEvent): void {
     validateRunEvent(event, "run-event");
     const run = this.run(event.runId);
     if (!run) throw runtimeError("run_unknown", event.runId, "run does not exist in this event store");
@@ -918,7 +918,7 @@ export class VnextRunEventStore {
     );
   }
 
-  events(runId: string, afterSequence = 0, limit = 200): VnextRunEvent[] {
+  events(runId: string, afterSequence = 0, limit = 200): KxmRunEvent[] {
     const rows = this.database.prepare(`
       SELECT project_id, run_id, sequence, event_id, event_type, command_id, occurred_at, recorded_at, monotonic_ns, config_revision, memory_revision, executor_policy_revision, tool_policy_revision, payload, schema, home_runtime_id
       FROM events WHERE run_id = ? AND sequence > ? ORDER BY sequence ASC LIMIT ?
@@ -937,7 +937,7 @@ export class VnextRunEventStore {
       executor_policy_revision: string;
       tool_policy_revision: string;
       payload: string;
-      schema: typeof VNEXT_RUN_EVENT_SCHEMA;
+      schema: typeof KXM_RUN_EVENT_SCHEMA;
       home_runtime_id: string;
     }>;
     return rows.map((row) => ({
@@ -960,12 +960,12 @@ export class VnextRunEventStore {
     }));
   }
 
-  insertRunPlan(row: VnextRunPlanRow): void {
+  insertRunPlan(row: KxmRunPlanRow): void {
     this.database.prepare("INSERT INTO run_plans (run_id, run_plan_hash, envelope, pinned_sequence) VALUES (?, ?, ?, ?)")
       .run(row.runId, row.runPlanHash, row.envelope, row.pinnedSequence);
   }
 
-  runPlan(runId: string): VnextRunPlanRow | undefined {
+  runPlan(runId: string): KxmRunPlanRow | undefined {
     const row = this.database.prepare("SELECT run_id, run_plan_hash, envelope, pinned_sequence FROM run_plans WHERE run_id = ?").get(runId) as
       | { run_id: string; run_plan_hash: string; envelope: string; pinned_sequence: number }
       | undefined;
@@ -974,23 +974,23 @@ export class VnextRunEventStore {
       : undefined;
   }
 
-  runState(runId: string): VnextRunStateRow | undefined {
+  runState(runId: string): KxmRunStateRow | undefined {
     const row = this.database.prepare("SELECT run_id, last_sequence, state FROM run_state WHERE run_id = ?").get(runId) as
       | { run_id: string; last_sequence: number; state: string }
       | undefined;
     return row ? { runId: row.run_id, lastSequence: row.last_sequence, state: row.state } : undefined;
   }
 
-  upsertRunState(row: VnextRunStateRow): void {
+  upsertRunState(row: KxmRunStateRow): void {
     this.database.prepare(`
       INSERT INTO run_state (run_id, last_sequence, state) VALUES (?, ?, ?)
       ON CONFLICT(run_id) DO UPDATE SET last_sequence = excluded.last_sequence, state = excluded.state
     `).run(row.runId, row.lastSequence, row.state);
   }
 
-  insertDriveReceipt(receipt: VnextDriveReceipt): { inserted: boolean } {
+  insertDriveReceipt(receipt: KxmDriveReceipt): { inserted: boolean } {
     validateDriveReceipt(receipt, "drive-receipt");
-    const canonical = vnextCanonicalJson(receipt as unknown as JsonValue);
+    const canonical = kxmCanonicalJson(receipt as unknown as JsonValue);
     if (Buffer.byteLength(canonical, "utf8") > DRIVE_RECEIPT_MAX_BYTES) {
       throw runtimeError("drive_receipt_invalid", receipt.driveId, `drive receipt exceeds ${DRIVE_RECEIPT_MAX_BYTES} bytes`);
     }
@@ -1011,14 +1011,14 @@ export class VnextRunEventStore {
     return { inserted: Number(result.changes) === 1 };
   }
 
-  driveReceipt(driveId: string): VnextDriveReceipt | undefined {
+  driveReceipt(driveId: string): KxmDriveReceipt | undefined {
     const row = this.database.prepare("SELECT receipt FROM drive_receipts WHERE drive_id = ?").get(driveId) as
       | { receipt: string }
       | undefined;
     return row ? parseDriveReceipt(row.receipt) : undefined;
   }
 
-  driveReceiptsForRun(runId: string, limit = 20): VnextDriveReceiptListItem[] {
+  driveReceiptsForRun(runId: string, limit = 20): KxmDriveReceiptListItem[] {
     const rows = this.database.prepare(`
       SELECT drive_id, receipt FROM drive_receipts WHERE run_id = ? ORDER BY closed_at DESC, drive_id DESC LIMIT ?
     `).all(runId, limit) as Array<{ drive_id: string; receipt: string }>;
@@ -1031,21 +1031,21 @@ export class VnextRunEventStore {
     });
   }
 
-  insertCapability(row: VnextAttemptCapabilityRow): void {
+  insertCapability(row: KxmAttemptCapabilityRow): void {
     this.database.prepare(`
       INSERT INTO attempt_capabilities (attempt_id, run_id, assignment_id, step_id, step_attempt, producer_id, capability_hash, state)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `).run(row.attemptId, row.runId, row.assignmentId, row.stepId, row.stepAttempt, row.producerId, row.capabilityHash, row.state);
   }
 
-  capabilityByHash(capabilityHash: string): VnextAttemptCapabilityRow | undefined {
+  capabilityByHash(capabilityHash: string): KxmAttemptCapabilityRow | undefined {
     return capabilityFromRow(this.database.prepare(`
       SELECT attempt_id, run_id, assignment_id, step_id, step_attempt, producer_id, capability_hash, state
       FROM attempt_capabilities WHERE capability_hash = ?
     `).get(capabilityHash) as CapabilitySqlRow | undefined);
   }
 
-  capabilityByAttempt(attemptId: string): VnextAttemptCapabilityRow | undefined {
+  capabilityByAttempt(attemptId: string): KxmAttemptCapabilityRow | undefined {
     return capabilityFromRow(this.database.prepare(`
       SELECT attempt_id, run_id, assignment_id, step_id, step_attempt, producer_id, capability_hash, state
       FROM attempt_capabilities WHERE attempt_id = ?
@@ -1059,7 +1059,7 @@ export class VnextRunEventStore {
     }
   }
 
-  insertGateAttempt(row: VnextGateAttemptRow): void {
+  insertGateAttempt(row: KxmGateAttemptRow): void {
     assertGateAttemptRow(row);
     this.assertEventType(row.runId, row.intentEventId, ["effect.intent_recorded"]);
     const capability = this.capabilityByAttempt(row.attemptId);
@@ -1085,7 +1085,7 @@ export class VnextRunEventStore {
     );
   }
 
-  insertGateObservation(row: VnextGateObservationRow): void {
+  insertGateObservation(row: KxmGateObservationRow): void {
     assertGateObservationRow(row);
     this.assertEventType(row.runId, row.recordedEventId, ["effect.observed", "effect.blocked_uncertain"]);
     const attempt = this.gateAttempt(row.attemptId);
@@ -1108,7 +1108,7 @@ export class VnextRunEventStore {
     );
   }
 
-  insertGateEvidence(row: VnextGateEvidenceRow): void {
+  insertGateEvidence(row: KxmGateEvidenceRow): void {
     assertGateEvidenceRow(row);
     this.assertEventType(row.runId, row.settledEventId, ["effect.settled"]);
     const attempt = this.gateAttempt(row.attemptId);
@@ -1130,7 +1130,7 @@ export class VnextRunEventStore {
     );
   }
 
-  gateAttempt(attemptId: string): VnextGateAttemptRow | undefined {
+  gateAttempt(attemptId: string): KxmGateAttemptRow | undefined {
     const row = this.database.prepare(`
       SELECT attempt_id, run_id, project_id, home_runtime_id, step_id, step_attempt, assignment_id, effect_id,
         gate_id, gate_kind, expect, gate_definition_hash, registry_hash, run_plan_hash, control_project_key,
@@ -1140,7 +1140,7 @@ export class VnextRunEventStore {
     return row ? gateAttemptFromSql(row) : undefined;
   }
 
-  gateAttemptsForRun(runId: string): VnextGateAttemptRow[] {
+  gateAttemptsForRun(runId: string): KxmGateAttemptRow[] {
     const rows = this.database.prepare(`
       SELECT attempt_id, run_id, project_id, home_runtime_id, step_id, step_attempt, assignment_id, effect_id,
         gate_id, gate_kind, expect, gate_definition_hash, registry_hash, run_plan_hash, control_project_key,
@@ -1150,7 +1150,7 @@ export class VnextRunEventStore {
     return rows.map(gateAttemptFromSql);
   }
 
-  gateAttemptsForProject(projectId: string): VnextGateAttemptRow[] {
+  gateAttemptsForProject(projectId: string): KxmGateAttemptRow[] {
     const rows = this.database.prepare(`
       SELECT attempt_id, run_id, project_id, home_runtime_id, step_id, step_attempt, assignment_id, effect_id,
         gate_id, gate_kind, expect, gate_definition_hash, registry_hash, run_plan_hash, control_project_key,
@@ -1160,14 +1160,14 @@ export class VnextRunEventStore {
     return rows.map(gateAttemptFromSql);
   }
 
-  issuedOrRevokedCapabilities(): VnextAttemptCapabilityRow[] {
+  issuedOrRevokedCapabilities(): KxmAttemptCapabilityRow[] {
     const rows = this.database.prepare(`
       SELECT attempt_id, run_id, assignment_id, step_id, step_attempt, producer_id, capability_hash, state
       FROM attempt_capabilities
       WHERE state IN ('issued','revoked')
       ORDER BY run_id ASC, step_attempt ASC, attempt_id ASC
     `).all() as CapabilitySqlRow[];
-    const mapped: VnextAttemptCapabilityRow[] = [];
+    const mapped: KxmAttemptCapabilityRow[] = [];
     for (const row of rows) {
       const capability = capabilityFromRow(row);
       if (!capability) {
@@ -1178,7 +1178,7 @@ export class VnextRunEventStore {
     return mapped;
   }
 
-  gateObservationForAttempt(attemptId: string): VnextGateObservationRow | undefined {
+  gateObservationForAttempt(attemptId: string): KxmGateObservationRow | undefined {
     const row = this.database.prepare(`
       SELECT observation_id, attempt_id, run_id, project_id, home_runtime_id, step_id, step_attempt, assignment_id,
         effect_id, completeness, spawned, pid, exit_code, signal, exit_observed, close_observed, stop_cause,
@@ -1189,7 +1189,7 @@ export class VnextRunEventStore {
     return row ? gateObservationFromSql(row) : undefined;
   }
 
-  gateObservationsForRun(runId: string): VnextGateObservationRow[] {
+  gateObservationsForRun(runId: string): KxmGateObservationRow[] {
     const rows = this.database.prepare(`
       SELECT observation_id, attempt_id, run_id, project_id, home_runtime_id, step_id, step_attempt, assignment_id,
         effect_id, completeness, spawned, pid, exit_code, signal, exit_observed, close_observed, stop_cause,
@@ -1200,7 +1200,7 @@ export class VnextRunEventStore {
     return rows.map(gateObservationFromSql);
   }
 
-  gateEvidenceForRun(runId: string): VnextGateEvidenceRow[] {
+  gateEvidenceForRun(runId: string): KxmGateEvidenceRow[] {
     const rows = this.database.prepare(`
       SELECT evidence_id, attempt_id, observation_id, run_id, project_id, home_runtime_id, step_id, step_attempt,
         assignment_id, effect_id, evidence_key, kind, expect, outcome, settled_event_id, content_hash
@@ -1209,7 +1209,7 @@ export class VnextRunEventStore {
     return rows.map(gateEvidenceFromSql);
   }
 
-  gateEvidenceForAttempt(attemptId: string): VnextGateEvidenceRow | undefined {
+  gateEvidenceForAttempt(attemptId: string): KxmGateEvidenceRow | undefined {
     const row = this.database.prepare(`
       SELECT evidence_id, attempt_id, observation_id, run_id, project_id, home_runtime_id, step_id, step_attempt,
         assignment_id, effect_id, evidence_key, kind, expect, outcome, settled_event_id, content_hash
@@ -1218,7 +1218,7 @@ export class VnextRunEventStore {
     return row ? gateEvidenceFromSql(row) : undefined;
   }
 
-  gateRowCounts(runId: string): VnextGateRowCounts {
+  gateRowCounts(runId: string): KxmGateRowCounts {
     const attempts = this.database.prepare("SELECT COUNT(*) AS n FROM gate_attempts WHERE run_id = ?").get(runId) as { n: number };
     const observations = this.database.prepare("SELECT COUNT(*) AS n FROM gate_observations WHERE run_id = ?").get(runId) as { n: number };
     const evidence = this.database.prepare("SELECT COUNT(*) AS n FROM gate_evidence WHERE run_id = ?").get(runId) as { n: number };
@@ -1235,10 +1235,10 @@ export class VnextRunEventStore {
   }
 }
 
-function parseDriveReceipt(raw: string): VnextDriveReceipt {
+function parseDriveReceipt(raw: string): KxmDriveReceipt {
   const parsed = JSON.parse(raw) as unknown;
   validateDriveReceipt(parsed, "drive-receipt");
-  return parsed as VnextDriveReceipt;
+  return parsed as KxmDriveReceipt;
 }
 
 function runFromRow(row: {
@@ -1247,14 +1247,14 @@ function runFromRow(row: {
   home_runtime_id: string;
   workflow_id: string;
   prompt_sha256: string;
-  status: VnextRunStatus;
+  status: KxmRunStatus;
   config_revision: string;
   memory_revision: string;
   executor_policy_revision: string;
   tool_policy_revision: string;
   created_at: string;
   updated_at: string;
-}): VnextRunRecord {
+}): KxmRunRecord {
   if (typeof row.memory_revision !== "string" || row.memory_revision.length === 0) {
     throw runtimeError("runtime_schema_shape_invalid", row.run_id, "memory_revision is required");
   }
@@ -1275,35 +1275,35 @@ function runFromRow(row: {
 }
 
 /** Compute the immutable identity for a new run. */
-export function newVnextRunId(): string {
+export function newKxmRunId(): string {
   return `run_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextEventId(): string {
+export function newKxmEventId(): string {
   return `evt_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextCommandId(): string {
+export function newKxmCommandId(): string {
   return `cmd_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextAssignmentId(): string {
+export function newKxmAssignmentId(): string {
   return `asg_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextAttemptId(): string {
+export function newKxmAttemptId(): string {
   return `att_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextEffectId(): string {
+export function newKxmEffectId(): string {
   return `eff_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextObservationId(): string {
+export function newKxmObservationId(): string {
   return `obs_${randomUUID().replaceAll("-", "")}`;
 }
 
-export function newVnextEvidenceId(): string {
+export function newKxmEvidenceId(): string {
   return `gev_${randomUUID().replaceAll("-", "")}`;
 }
 
@@ -1330,11 +1330,11 @@ export function gateRowContentHash(table: "gate_attempts" | "gate_observations"
   const copy = { ...(row as Record<string, unknown>) };
   delete copy.contentHash;
   void table;
-  return `sha256:${createHash("sha256").update(vnextCanonicalJson(copy as JsonValue), "utf8").digest("hex")}`;
+  return `sha256:${createHash("sha256").update(kxmCanonicalJson(copy as JsonValue), "utf8").digest("hex")}`;
 }
 
-export type VnextGateObservationFacts = Pick<
-  VnextGateObservationRow,
+export type KxmGateObservationFacts = Pick<
+  KxmGateObservationRow,
   | "completeness"
   | "spawned"
   | "pid"
@@ -1356,8 +1356,8 @@ export type VnextGateObservationFacts = Pick<
 >;
 
 export function assertClosedGateObservation(
-  kind: VnextGateKind,
-  row: VnextGateObservationFacts,
+  kind: KxmGateKind,
+  row: KxmGateObservationFacts,
   id = "observation",
 ): void {
   if (row.completeness === "incomplete") return;
@@ -1435,10 +1435,10 @@ export function assertClosedGateObservation(
 }
 
 export function computeGateEvidenceOutcome(
-  kind: VnextGateKind,
-  expect: VnextGateExpect,
-  observation: VnextGateObservationFacts,
-): VnextGateEvidenceOutcome {
+  kind: KxmGateKind,
+  expect: KxmGateExpect,
+  observation: KxmGateObservationFacts,
+): KxmGateEvidenceOutcome {
   assertClosedGateObservation(kind, observation);
   if (observation.completeness !== "complete") {
     throw gateRowInvalid("observation", "evaluated settlement requires a complete observation");
@@ -1451,7 +1451,7 @@ export function computeGateEvidenceOutcome(
   return observation.exitCode === 0 ? "repro-missing" : "passed";
 }
 
-function gateRowInvalid(file: string, message: string): VnextConfigError {
+function gateRowInvalid(file: string, message: string): KxmConfigError {
   return runtimeError("gate_row_invalid", file, message);
 }
 
@@ -1485,7 +1485,7 @@ function assertNullInt(value: unknown, id: string, label: string): void {
   }
 }
 
-function assertGateAttemptRow(row: VnextGateAttemptRow): void {
+function assertGateAttemptRow(row: KxmGateAttemptRow): void {
   assertExactRowKeys(row, GATE_ATTEMPT_KEYS, row.attemptId);
   assertId(row.attemptId, "att_", row.attemptId, "attemptId");
   assertId(row.effectId, "eff_", row.attemptId, "effectId");
@@ -1509,7 +1509,7 @@ function assertGateAttemptRow(row: VnextGateAttemptRow): void {
   }
 }
 
-function assertGateObservationRow(row: VnextGateObservationRow): void {
+function assertGateObservationRow(row: KxmGateObservationRow): void {
   assertExactRowKeys(row, GATE_OBSERVATION_KEYS, row.observationId);
   assertId(row.observationId, "obs_", row.observationId, "observationId");
   assertId(row.attemptId, "att_", row.observationId, "attemptId");
@@ -1543,7 +1543,7 @@ function assertGateObservationRow(row: VnextGateObservationRow): void {
   }
 }
 
-function assertGateEvidenceRow(row: VnextGateEvidenceRow): void {
+function assertGateEvidenceRow(row: KxmGateEvidenceRow): void {
   assertExactRowKeys(row, GATE_EVIDENCE_KEYS, row.evidenceId);
   assertId(row.evidenceId, "gev_", row.evidenceId, "evidenceId");
   assertId(row.attemptId, "att_", row.evidenceId, "attemptId");
@@ -1561,7 +1561,7 @@ function assertGateEvidenceRow(row: VnextGateEvidenceRow): void {
 
 function assertSharedIdentity(
   row: { runId: string; projectId: string; homeRuntimeId: string; stepId: string; stepAttempt: number; assignmentId: string; effectId: string },
-  attempt: VnextGateAttemptRow,
+  attempt: KxmGateAttemptRow,
   id: string,
 ): void {
   if (
@@ -1587,8 +1587,8 @@ type GateAttemptSql = {
   assignment_id: string;
   effect_id: string;
   gate_id: string;
-  gate_kind: VnextGateKind;
-  expect: VnextGateExpect;
+  gate_kind: KxmGateKind;
+  expect: KxmGateExpect;
   gate_definition_hash: string;
   registry_hash: string;
   run_plan_hash: string;
@@ -1598,7 +1598,7 @@ type GateAttemptSql = {
   content_hash: string;
 };
 
-function gateAttemptFromSql(row: GateAttemptSql): VnextGateAttemptRow {
+function gateAttemptFromSql(row: GateAttemptSql): KxmGateAttemptRow {
   return {
     attemptId: row.attempt_id,
     runId: row.run_id,
@@ -1631,16 +1631,16 @@ type GateObservationSql = {
   step_attempt: number;
   assignment_id: string;
   effect_id: string;
-  completeness: VnextGateCompleteness;
+  completeness: KxmGateCompleteness;
   spawned: number;
   pid: number | null;
   exit_code: number | null;
   signal: string | null;
   exit_observed: number;
   close_observed: number;
-  stop_cause: VnextGateStopCause;
-  signals_attempted: VnextGateSignalsAttempted;
-  error_class: VnextGateErrorClass | null;
+  stop_cause: KxmGateStopCause;
+  signals_attempted: KxmGateSignalsAttempted;
+  error_class: KxmGateErrorClass | null;
   stdout_sha256: string | null;
   stdout_bytes: number | null;
   stdout_complete: number | null;
@@ -1656,7 +1656,7 @@ type GateObservationSql = {
   content_hash: string;
 };
 
-function gateObservationFromSql(row: GateObservationSql): VnextGateObservationRow {
+function gateObservationFromSql(row: GateObservationSql): KxmGateObservationRow {
   return {
     observationId: row.observation_id,
     attemptId: row.attempt_id,
@@ -1706,13 +1706,13 @@ type GateEvidenceSql = {
   effect_id: string;
   evidence_key: string | null;
   kind: "gate";
-  expect: VnextGateExpect;
-  outcome: VnextGateEvidenceOutcome;
+  expect: KxmGateExpect;
+  outcome: KxmGateEvidenceOutcome;
   settled_event_id: string;
   content_hash: string;
 };
 
-function gateEvidenceFromSql(row: GateEvidenceSql): VnextGateEvidenceRow {
+function gateEvidenceFromSql(row: GateEvidenceSql): KxmGateEvidenceRow {
   return {
     evidenceId: row.evidence_id,
     attemptId: row.attempt_id,
@@ -1741,10 +1741,10 @@ type CapabilitySqlRow = {
   step_attempt: number;
   producer_id: string;
   capability_hash: string;
-  state: VnextAttemptCapabilityRow["state"];
+  state: KxmAttemptCapabilityRow["state"];
 };
 
-function capabilityFromRow(row: CapabilitySqlRow | undefined): VnextAttemptCapabilityRow | undefined {
+function capabilityFromRow(row: CapabilitySqlRow | undefined): KxmAttemptCapabilityRow | undefined {
   return row
     ? {
       attemptId: row.attempt_id,