@kontextmind/kxm 0.7.40 → 0.7.43

package/plugins/kxm/src/cli/{vnext.ts → project.ts}

@@ -7,25 +7,25 @@ import { createBackup, restoreBackup } from "../database.ts";
 import { refreshModelInventory } from "../model-inventory.ts";
 import { listInventoryModels, listRoleBindings, loadRoutePolicy, setRouteState, updateRouteState } from "../routes.ts";
 import {
-  VnextConfigError,
-  discoverVnextProjectRoot,
-  type VnextInitializationPlan,
-} from "../vnext-config.ts";
-import { initializeVnextProject } from "../vnext-init.ts";
-import { applyVnextMigration, planVnextMigration, verifyVnextMigration } from "../vnext-migrate.ts";
-import { diffVnextProjectAgainstRevision, formatVnextPermissionDiff } from "../vnext-permission.ts";
-import { readVnextLocalBindings, vnextUserStateRoot } from "../vnext-bindings.ts";
-import { loadVnextProject } from "../vnext-config.ts";
+  KxmConfigError,
+  discoverKxmProjectRoot,
+  type KxmInitializationPlan,
+} from "../project-config.ts";
+import { initializeKxmProject } from "../init.ts";
+import { applyKxmMigration, planKxmMigration, verifyKxmMigration } from "../migrate.ts";
+import { diffKxmProjectAgainstRevision, formatKxmPermissionDiff } from "../permission.ts";
+import { readKxmLocalBindings, kxmUserStateRoot } from "../bindings.ts";
+import { loadKxmProject } from "../project-config.ts";
 import {
-  ensureVnextSupervisor,
-  vnextRuntimeRequest,
-  vnextSupervisorStatus,
-} from "../vnext-runtime-supervisor.ts";
-import { vnextRuntimePaths } from "../vnext-runtime-store.ts";
+  ensureKxmSupervisor,
+  kxmRuntimeRequest,
+  kxmSupervisorStatus,
+} from "../runtime-supervisor.ts";
+import { kxmRuntimePaths } from "../runtime-store.ts";
 import {
   formatHarnessInventory,
   probeHarnessesAsync,
-} from "../vnext-harness.ts";
+} from "../harness.ts";
 import {
   fetchLatestKxmVersion,
   kxmReleaseAssetName,
@@ -42,12 +42,12 @@ import { loadKxmUpdateConfig } from "../kxm-update-config.ts";
 import type { InstallKindReport, InstallProbe } from "../kxm-install-kind.ts";
 import { print, type CliIo, type CliSpawnResult, type Runtime } from "./types.ts";
 
-export const vnextDriveCliSeams: {
-  ensureSupervisor?: typeof ensureVnextSupervisor;
-  runtimeRequest?: typeof vnextRuntimeRequest;
+export const kxmDriveCliSeams: {
+  ensureSupervisor?: typeof ensureKxmSupervisor;
+  runtimeRequest?: typeof kxmRuntimeRequest;
 } = {};
 
-export function initPlanPayload(plan: VnextInitializationPlan): Record<string, unknown> {
+export function initPlanPayload(plan: KxmInitializationPlan): Record<string, unknown> {
   return {
     mode: plan.mode,
     inspectedFrom: plan.inspectedFrom,
@@ -67,7 +67,7 @@ export function explicitRepositoryBindings(values: readonly string[]): Readonly<
     const repositoryId = separator < 0 ? "" : value.slice(0, separator).trim();
     const path = separator < 0 ? "" : value.slice(separator + 1).trim();
     if (!repositoryId || !path) {
-      throw new VnextConfigError([{
+      throw new KxmConfigError([{
         phase: "discovery",
         code: "repository_binding_argument_invalid",
         file: "--repository",
@@ -75,7 +75,7 @@ export function explicitRepositoryBindings(values: readonly string[]): Readonly<
       }]);
     }
     if (Object.hasOwn(result, repositoryId)) {
-      throw new VnextConfigError([{
+      throw new KxmConfigError([{
         phase: "discovery",
         code: "repository_binding_argument_duplicate",
         file: "--repository",
@@ -87,7 +87,7 @@ export function explicitRepositoryBindings(values: readonly string[]): Readonly<
   return result;
 }
 
-export async function cmdVnextInit(
+export async function cmdKxmInit(
   runtime: Runtime,
   options: { name?: string | undefined; projectId?: string | undefined; repository?: string[] | undefined },
   postHooks?: {
@@ -104,11 +104,11 @@ export async function cmdVnextInit(
     return 2;
   }
   try {
-    const initialized = initializeVnextProject(runtime.cwd, {
+    const initialized = initializeKxmProject(runtime.cwd, {
       ...(options.name?.trim() ? { projectName: options.name.trim() } : {}),
       ...(options.projectId?.trim() ? { projectId: options.projectId.trim() } : {}),
       repositoryBindings: explicitRepositoryBindings(options.repository ?? []),
-      localStateRoot: vnextUserStateRoot({ env: runtime.env }),
+      localStateRoot: kxmUserStateRoot({ env: runtime.env }),
       dryRun: runtime.dryRun,
     });
     const payload = {
@@ -132,21 +132,21 @@ export async function cmdVnextInit(
     if (initialized.action === "created") {
       if (postHooks?.maybeOfferCompletionInstall) await postHooks.maybeOfferCompletionInstall(runtime);
       if (postHooks?.maybeOfferGuideSetup) await postHooks.maybeOfferGuideSetup(runtime);
-      return finishInit(0, `initialized vNext project at ${initialized.projectRoot ?? runtime.cwd}`);
+      return finishInit(0, `initialized KXM project at ${initialized.projectRoot ?? runtime.cwd}`);
     }
     if (initialized.action === "joined") {
       if (postHooks?.maybeOfferCompletionInstall) await postHooks.maybeOfferCompletionInstall(runtime);
       if (postHooks?.maybeOfferGuideSetup) await postHooks.maybeOfferGuideSetup(runtime);
-      return finishInit(0, `joined vNext project at ${initialized.projectRoot ?? runtime.cwd}`);
+      return finishInit(0, `joined KXM project at ${initialized.projectRoot ?? runtime.cwd}`);
     }
     if (initialized.action === "repaired") {
-      return finishInit(0, `repaired vNext project at ${initialized.projectRoot ?? runtime.cwd}`);
+      return finishInit(0, `repaired KXM project at ${initialized.projectRoot ?? runtime.cwd}`);
     }
     if (initialized.action === "resumed") {
-      return finishInit(0, `resumed vNext ${initialized.transactionKind ?? "initialization"} at ${initialized.projectRoot ?? runtime.cwd}`);
+      return finishInit(0, `resumed KXM ${initialized.transactionKind ?? "initialization"} at ${initialized.projectRoot ?? runtime.cwd}`);
     }
     if (initialized.action === "validated") {
-      return finishInit(0, `validated vNext project at ${initialized.projectRoot ?? runtime.cwd}`);
+      return finishInit(0, `validated KXM project at ${initialized.projectRoot ?? runtime.cwd}`);
     }
     if (runtime.dryRun) {
       return finishInit(0, `init plan: ${initialized.plan.mode}`);
@@ -155,28 +155,28 @@ export async function cmdVnextInit(
       ? "legacy state requires reviewed migration; conversion is not available in this implementation slice"
       : initialized.repairPlan?.issues.length
         ? "managed-template repair is blocked by conflicts or authority changes; local files were preserved"
-        : "partial or provenance-free vNext state requires explicit repair; no files were overwritten";
+        : "partial or provenance-free KXM state requires explicit repair; no files were overwritten";
     return finishInit(1, next);
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, {
         ok: false,
         command: "init",
-        error: "vnext_initialization_failed",
+        error: "initialization_failed",
         issues: error.issues,
-      }, `vNext initialization failed: ${error.message}`);
+      }, `KXM initialization failed: ${error.message}`);
       return 1;
     }
     print(runtime.io, runtime.json, {
       ok: false,
       command: "init",
-      error: "vnext_initialization_io_failed",
-    }, "vNext initialization failed because a local filesystem operation did not complete");
+      error: "initialization_io_failed",
+    }, "KXM initialization failed because a local filesystem operation did not complete");
     return 1;
   }
 }
 
-export async function cmdVnextMigratePlan(runtime: Runtime): Promise<number> {
+export async function cmdKxmMigratePlan(runtime: Runtime): Promise<number> {
   if (runtime.workspaceFlag !== undefined) {
     print(runtime.io, runtime.json, {
       ok: false,
@@ -186,7 +186,7 @@ export async function cmdVnextMigratePlan(runtime: Runtime): Promise<number> {
     return 2;
   }
   try {
-    const result = planVnextMigration(runtime.cwd, {});
+    const result = planKxmMigration(runtime.cwd, {});
     const ambiguities = (result.plan.ambiguities as Array<{ key: string; message: string }> | undefined) ?? [];
     const unmapped = (result.plan.unmapped as unknown[] | undefined) ?? [];
     const payload = {
@@ -207,7 +207,7 @@ export async function cmdVnextMigratePlan(runtime: Runtime): Promise<number> {
     );
     return 1;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "migrate plan", error: "migration_plan_failed", issues: error.issues }, `migration plan failed: ${error.message}`);
       return 1;
     }
@@ -216,7 +216,7 @@ export async function cmdVnextMigratePlan(runtime: Runtime): Promise<number> {
   }
 }
 
-export async function cmdVnextMigrateApply(runtime: Runtime, options: { decisions?: string | undefined; projectId?: string | undefined; name?: string | undefined }): Promise<number> {
+export async function cmdKxmMigrateApply(runtime: Runtime, options: { decisions?: string | undefined; projectId?: string | undefined; name?: string | undefined }): Promise<number> {
   if (runtime.workspaceFlag !== undefined) {
     print(runtime.io, runtime.json, {
       ok: false,
@@ -226,11 +226,11 @@ export async function cmdVnextMigrateApply(runtime: Runtime, options: { decision
     return 2;
   }
   try {
-    const result = applyVnextMigration(runtime.cwd, {
+    const result = applyKxmMigration(runtime.cwd, {
       ...(options.decisions?.trim() ? { decisionsFile: options.decisions.trim() } : {}),
       ...(options.projectId?.trim() ? { projectId: options.projectId.trim() } : {}),
       ...(options.name?.trim() ? { projectName: options.name.trim() } : {}),
-      localStateRoot: vnextUserStateRoot({ env: runtime.env }),
+      localStateRoot: kxmUserStateRoot({ env: runtime.env }),
       dryRun: runtime.dryRun,
     });
     const payload = {
@@ -263,7 +263,7 @@ export async function cmdVnextMigrateApply(runtime: Runtime, options: { decision
     );
     return 1;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "migrate apply", error: "migration_apply_failed", issues: error.issues }, `migration apply failed: ${error.message}`);
       return 1;
     }
@@ -272,7 +272,7 @@ export async function cmdVnextMigrateApply(runtime: Runtime, options: { decision
   }
 }
 
-export async function cmdVnextMigrateVerify(runtime: Runtime): Promise<number> {
+export async function cmdKxmMigrateVerify(runtime: Runtime): Promise<number> {
   if (runtime.workspaceFlag !== undefined) {
     print(runtime.io, runtime.json, {
       ok: false,
@@ -281,11 +281,11 @@ export async function cmdVnextMigrateVerify(runtime: Runtime): Promise<number> {
     }, "kxm migrate discovers the authoritative Git root from the current directory; --workspace is not supported");
     return 2;
   }
-  let result: ReturnType<typeof verifyVnextMigration>;
+  let result: ReturnType<typeof verifyKxmMigration>;
   try {
-    result = verifyVnextMigration(runtime.cwd, {});
+    result = verifyKxmMigration(runtime.cwd, {});
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "migrate verify", error: "migration_verify_failed", issues: error.issues }, `migration verification failed: ${error.message}`);
       return 1;
     }
@@ -327,7 +327,7 @@ export async function cmdBackup(runtime: Runtime, options: { out?: string | unde
     print(runtime.io, runtime.json, payload, summary);
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "backup", error: "backup_failed", issues: error.issues }, `backup failed: ${error.message}`);
       return 1;
     }
@@ -355,7 +355,7 @@ export async function cmdRestore(runtime: Runtime, manifestArg: string): Promise
     print(runtime.io, runtime.json, payload, summary);
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "restore", error: "restore_failed", issues: error.issues }, `restore failed: ${error.message}`);
       return 1;
     }
@@ -364,7 +364,7 @@ export async function cmdRestore(runtime: Runtime, manifestArg: string): Promise
   }
 }
 
-export async function cmdVnextTrust(runtime: Runtime, check: boolean, options: { base?: string | undefined }): Promise<number> {
+export async function cmdKxmTrust(runtime: Runtime, check: boolean, options: { base?: string | undefined }): Promise<number> {
   if (runtime.workspaceFlag !== undefined) {
     print(runtime.io, runtime.json, {
       ok: false,
@@ -375,9 +375,9 @@ export async function cmdVnextTrust(runtime: Runtime, check: boolean, options: {
   }
   const command = check ? "trust check" : "trust diff";
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd) ?? runtime.cwd;
-    const bindings = readVnextLocalBindings(projectRoot, { stateRoot: vnextUserStateRoot({ env: runtime.env }) });
-    const diff = diffVnextProjectAgainstRevision(projectRoot, options.base?.trim() || "HEAD", {
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd) ?? runtime.cwd;
+    const bindings = readKxmLocalBindings(projectRoot, { stateRoot: kxmUserStateRoot({ env: runtime.env }) });
+    const diff = diffKxmProjectAgainstRevision(projectRoot, options.base?.trim() || "HEAD", {
       repositoryBindings: bindings?.repositories ?? {},
     });
     const payload = {
@@ -391,7 +391,7 @@ export async function cmdVnextTrust(runtime: Runtime, check: boolean, options: {
       neutralChanges: diff.neutralChanges.length,
       changes: diff.changes,
     };
-    const text = formatVnextPermissionDiff(diff);
+    const text = formatKxmPermissionDiff(diff);
     if (check && diff.requiresReview) {
       print(runtime.io, runtime.json, payload, `${text}\ntrust check failed: review every expansion above before merging`);
       return 1;
@@ -399,7 +399,7 @@ export async function cmdVnextTrust(runtime: Runtime, check: boolean, options: {
     print(runtime.io, runtime.json, payload, text);
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command, error: "trust_diff_failed", issues: error.issues }, `permission diff failed: ${error.message}`);
       return 1;
     }
@@ -411,7 +411,7 @@ export async function cmdVnextTrust(runtime: Runtime, check: boolean, options: {
 export const RUN_ENGINE_PHASE = "pre-3a";
 export const RUN_ENGINE_NOTICE = "runs remain created until the run engine lands; no steps execute yet";
 
-export async function cmdVnextRun(runtime: Runtime, workflow: string | undefined, promptParts: string[]): Promise<number> {
+export async function cmdKxmRun(runtime: Runtime, workflow: string | undefined, promptParts: string[]): Promise<number> {
   if (runtime.workspaceFlag !== undefined) {
     print(runtime.io, runtime.json, {
       ok: false,
@@ -425,12 +425,12 @@ export async function cmdVnextRun(runtime: Runtime, workflow: string | undefined
     return 2;
   }
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "run", error: "project_required" }, "kxm run requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "run", error: "project_required" }, "kxm run requires a KXM project (run kxm init first)");
       return 1;
     }
-    const bundle = loadVnextProject(projectRoot, {});
+    const bundle = loadKxmProject(projectRoot, {});
     if (!bundle.workflows.has(workflow)) {
       print(runtime.io, runtime.json, { ok: false, command: "run", error: "run_workflow_unknown", workflow }, `workflow ${workflow} does not exist in this project`);
       return 1;
@@ -446,9 +446,9 @@ export async function cmdVnextRun(runtime: Runtime, workflow: string | undefined
       }, `run plan: workflow ${workflow} at ${bundle.configRevision.slice(0, 19)}… (no run created)`);
       return 0;
     }
-    const supervisor = await ensureVnextSupervisor({ env: runtime.env });
+    const supervisor = await ensureKxmSupervisor({ env: runtime.env });
     const prompt = promptParts.join(" ").trim();
-    const acceptance = await vnextRuntimeRequest(supervisor, "POST", "/v1/runs", {
+    const acceptance = await kxmRuntimeRequest(supervisor, "POST", "/v1/runs", {
       projectRoot,
       workflowId: workflow,
       prompt,
@@ -464,7 +464,7 @@ export async function cmdVnextRun(runtime: Runtime, workflow: string | undefined
     }, `run ${run.status}: ${run.runId} (home ${run.homeRuntimeId.slice(0, 12)}…, config ${run.configRevision.slice(0, 19)}…)\n${RUN_ENGINE_NOTICE}`);
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "run", error: "run_failed", issues: error.issues }, `run failed: ${error.message}`);
       return 1;
     }
@@ -473,7 +473,7 @@ export async function cmdVnextRun(runtime: Runtime, workflow: string | undefined
   }
 }
 
-interface VnextStatusDrive {
+interface KxmStatusDrive {
   driveId?: string;
   mode?: string;
   openedAt?: string;
@@ -488,7 +488,7 @@ function formatCancelledStatus(reason: string): string {
   return reason.length > 0 ? `cancelled (${reason})` : "cancelled";
 }
 
-function formatDriveStatusLine(runStatus: string, drive: VnextStatusDrive | undefined): string | undefined {
+function formatDriveStatusLine(runStatus: string, drive: KxmStatusDrive | undefined): string | undefined {
   if (!drive || typeof drive.driveId !== "string" || drive.driveId.length === 0) return undefined;
   const receipt = drive.receipt ?? null;
   if (receipt === null) {
@@ -521,24 +521,24 @@ function formatDriveStatusLine(runStatus: string, drive: VnextStatusDrive | unde
 
 function formatRunStatusLine(
   run: { runId: string; status: string; workflowId: string; updatedAt: string },
-  drive: VnextStatusDrive | undefined,
+  drive: KxmStatusDrive | undefined,
 ): string {
   const reason = typeof drive?.receipt?.settlement?.reason === "string" ? drive.receipt.settlement.reason : "";
   const statusLabel = run.status === "cancelled" ? formatCancelledStatus(reason) : run.status;
   return `run ${run.runId}: ${statusLabel} (workflow ${run.workflowId}, updated ${run.updatedAt})`;
 }
 
-export async function cmdVnextRunStatus(runtime: Runtime, runId: string): Promise<number> {
+export async function cmdKxmRunStatus(runtime: Runtime, runId: string): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "runs status", error: "project_required" }, "kxm runs status requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "runs status", error: "project_required" }, "kxm runs status requires a KXM project (run kxm init first)");
       return 1;
     }
-    const supervisor = await (vnextDriveCliSeams.ensureSupervisor ?? ensureVnextSupervisor)({ env: runtime.env });
-    const result = await (vnextDriveCliSeams.runtimeRequest ?? vnextRuntimeRequest)(supervisor, "GET", `/v1/runs/${encodeURIComponent(runId)}?projectRoot=${encodeURIComponent(projectRoot)}`);
+    const supervisor = await (kxmDriveCliSeams.ensureSupervisor ?? ensureKxmSupervisor)({ env: runtime.env });
+    const result = await (kxmDriveCliSeams.runtimeRequest ?? kxmRuntimeRequest)(supervisor, "GET", `/v1/runs/${encodeURIComponent(runId)}?projectRoot=${encodeURIComponent(projectRoot)}`);
     const run = result.run as { runId: string; status: string; workflowId: string; configRevision: string; updatedAt: string };
-    const drive = result.drive as VnextStatusDrive | undefined;
+    const drive = result.drive as KxmStatusDrive | undefined;
     const driveLine = formatDriveStatusLine(run.status, drive);
     print(
       runtime.io,
@@ -548,7 +548,7 @@ export async function cmdVnextRunStatus(runtime: Runtime, runId: string): Promis
     );
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runs status", error: "run_status_failed", issues: error.issues }, `run status failed: ${error.message}`);
       return 1;
     }
@@ -571,22 +571,22 @@ function sleepMs(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function driveWaitCompleted(drive: VnextStatusDrive | undefined): boolean {
+function driveWaitCompleted(drive: KxmStatusDrive | undefined): boolean {
   return drive?.verified === true
     && drive.receipt?.settlement?.kind === "terminal"
     && drive.receipt.settlement.status === "completed";
 }
 
-export async function cmdVnextRunDrive(
+export async function cmdKxmRunDrive(
   runtime: Runtime,
   runId: string,
   simulated: boolean,
   options: { wait?: boolean; timeoutMs?: number | string } = {},
 ): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "runs drive", error: "project_required" }, "kxm runs drive requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "runs drive", error: "project_required" }, "kxm runs drive requires a KXM project (run kxm init first)");
       return 1;
     }
     const mode = simulated ? "simulated" : "live";
@@ -604,8 +604,8 @@ export async function cmdVnextRunDrive(
       );
       return 1;
     }
-    const supervisor = await (vnextDriveCliSeams.ensureSupervisor ?? ensureVnextSupervisor)({ env: runtime.env });
-    const request = vnextDriveCliSeams.runtimeRequest ?? vnextRuntimeRequest;
+    const supervisor = await (kxmDriveCliSeams.ensureSupervisor ?? ensureKxmSupervisor)({ env: runtime.env });
+    const request = kxmDriveCliSeams.runtimeRequest ?? kxmRuntimeRequest;
     const result = await request(supervisor, "POST", `/v1/runs/${encodeURIComponent(runId)}/drive?projectRoot=${encodeURIComponent(projectRoot)}`, { mode });
     const driveId = result.driveId;
     const poll = result.poll;
@@ -629,7 +629,7 @@ export async function cmdVnextRunDrive(
     let interval = 25;
     while (true) {
       const stateResult = await request(supervisor, "GET", `/v1/runs/${encodeURIComponent(runId)}?projectRoot=${encodeURIComponent(projectRoot)}`);
-      const drive = stateResult.drive as VnextStatusDrive | undefined;
+      const drive = stateResult.drive as KxmStatusDrive | undefined;
       if (drive?.receipt) {
         print(
           runtime.io,
@@ -648,7 +648,7 @@ export async function cmdVnextRunDrive(
     print(runtime.io, runtime.json, { ok: false, command: "runs drive", error: "timeout" }, "drive wait timed out");
     return 1;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runs drive", error: "run_drive_failed", issues: error.issues }, `run drive failed: ${error.message}`);
       return 1;
     }
@@ -657,19 +657,19 @@ export async function cmdVnextRunDrive(
   }
 }
 
-export async function cmdVnextRunCancel(runtime: Runtime, runId: string): Promise<number> {
+export async function cmdKxmRunCancel(runtime: Runtime, runId: string): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "runs cancel", error: "project_required" }, "kxm runs cancel requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "runs cancel", error: "project_required" }, "kxm runs cancel requires a KXM project (run kxm init first)");
       return 1;
     }
     if (runtime.dryRun) {
       print(runtime.io, runtime.json, { ok: true, command: "runs cancel", dryRun: true, runId }, `cancel plan: run ${runId} (no events written)`);
       return 0;
     }
-    const supervisor = await ensureVnextSupervisor({ env: runtime.env });
-    const result = await vnextRuntimeRequest(supervisor, "POST", `/v1/runs/${encodeURIComponent(runId)}/cancel?projectRoot=${encodeURIComponent(projectRoot)}`, {});
+    const supervisor = await ensureKxmSupervisor({ env: runtime.env });
+    const result = await kxmRuntimeRequest(supervisor, "POST", `/v1/runs/${encodeURIComponent(runId)}/cancel?projectRoot=${encodeURIComponent(projectRoot)}`, {});
     const run = result.run as { runId: string; status: string };
     print(runtime.io, runtime.json, {
       ok: true,
@@ -679,7 +679,7 @@ export async function cmdVnextRunCancel(runtime: Runtime, runId: string): Promis
     }, `run ${run.runId}: ${run.status}`);
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runs cancel", error: "run_cancel_failed", issues: error.issues }, `run cancel failed: ${error.message}`);
       return 1;
     }
@@ -688,17 +688,17 @@ export async function cmdVnextRunCancel(runtime: Runtime, runId: string): Promis
   }
 }
 
-export async function cmdVnextRunList(runtime: Runtime): Promise<number> {
+export async function cmdKxmRunList(runtime: Runtime): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "runs list", error: "project_required" }, "kxm runs list requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "runs list", error: "project_required" }, "kxm runs list requires a KXM project (run kxm init first)");
       return 1;
     }
-    const bundle = loadVnextProject(projectRoot, {});
+    const bundle = loadKxmProject(projectRoot, {});
     const projectId = String(bundle.project.value.id);
-    const supervisor = await ensureVnextSupervisor({ env: runtime.env });
-    const result = await vnextRuntimeRequest(supervisor, "GET", `/v1/projects/${encodeURIComponent(projectId)}/runs?projectRoot=${encodeURIComponent(projectRoot)}`);
+    const supervisor = await ensureKxmSupervisor({ env: runtime.env });
+    const result = await kxmRuntimeRequest(supervisor, "GET", `/v1/projects/${encodeURIComponent(projectId)}/runs?projectRoot=${encodeURIComponent(projectRoot)}`);
     const runs = (result.runs ?? []) as Array<{ runId: string; status: string; workflowId: string; createdAt: string }>;
     print(
       runtime.io,
@@ -708,7 +708,7 @@ export async function cmdVnextRunList(runtime: Runtime): Promise<number> {
     );
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runs list", error: "run_list_failed", issues: error.issues }, `run list failed: ${error.message}`);
       return 1;
     }
@@ -789,15 +789,15 @@ export async function cmdModelInventoryRefresh(runtime: Runtime): Promise<number
   return failed ? 1 : 0;
 }
 
-export async function cmdVnextRuntime(runtime: Runtime, action: string): Promise<number> {
-  const paths = vnextRuntimePaths({ env: runtime.env });
+export async function cmdKxmRuntime(runtime: Runtime, action: string): Promise<number> {
+  const paths = kxmRuntimePaths({ env: runtime.env });
   try {
     if (action === "start") {
       if (runtime.dryRun) {
         print(runtime.io, runtime.json, { ok: true, command: "runtime start", dryRun: true }, "runtime supervisor would auto-start");
         return 0;
       }
-      const supervisor = await ensureVnextSupervisor({ env: runtime.env });
+      const supervisor = await ensureKxmSupervisor({ env: runtime.env });
       print(runtime.io, runtime.json, {
         ok: true,
         command: "runtime start",
@@ -808,14 +808,14 @@ export async function cmdVnextRuntime(runtime: Runtime, action: string): Promise
       return 0;
     }
     if (action === "status") {
-      const status = vnextSupervisorStatus(paths);
+      const status = kxmSupervisorStatus(paths);
       print(runtime.io, runtime.json, { ok: true, command: "runtime status", ...status }, status.running
         ? `runtime supervisor running: ${status.runtimeId} pid ${status.pid} on 127.0.0.1:${status.port}`
         : "runtime supervisor is not running");
       return status.running ? 0 : 1;
     }
     if (action === "stop") {
-      const status = vnextSupervisorStatus(paths);
+      const status = kxmSupervisorStatus(paths);
       if (!status.running || !status.port) {
         print(runtime.io, runtime.json, { ok: true, command: "runtime stop", stopped: false }, "runtime supervisor is not running");
         return 0;
@@ -824,15 +824,15 @@ export async function cmdVnextRuntime(runtime: Runtime, action: string): Promise
         print(runtime.io, runtime.json, { ok: true, command: "runtime stop", dryRun: true }, `would stop runtime supervisor pid ${status.pid}`);
         return 0;
       }
-      const supervisor = await ensureVnextSupervisor({ env: runtime.env });
-      await vnextRuntimeRequest(supervisor, "POST", "/v1/shutdown", {});
+      const supervisor = await ensureKxmSupervisor({ env: runtime.env });
+      await kxmRuntimeRequest(supervisor, "POST", "/v1/shutdown", {});
       print(runtime.io, runtime.json, { ok: true, command: "runtime stop", stopped: true }, `runtime supervisor ${status.runtimeId} stopping`);
       return 0;
     }
     print(runtime.io, runtime.json, { ok: false, command: "runtime", error: "unknown_action" }, `unknown runtime action: ${action}`);
     return 2;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runtime", error: "runtime_failed", issues: error.issues }, `runtime failed: ${error.message}`);
       return 1;
     }
@@ -841,15 +841,15 @@ export async function cmdVnextRuntime(runtime: Runtime, action: string): Promise
   }
 }
 
-export async function cmdVnextRunReceipt(runtime: Runtime, runId: string, options: { all?: boolean } = {}): Promise<number> {
+export async function cmdKxmRunReceipt(runtime: Runtime, runId: string, options: { all?: boolean } = {}): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (!projectRoot) {
-      print(runtime.io, runtime.json, { ok: false, command: "runs receipt", error: "project_required" }, "kxm runs receipt requires a vNext project (run kxm init first)");
+      print(runtime.io, runtime.json, { ok: false, command: "runs receipt", error: "project_required" }, "kxm runs receipt requires a KXM project (run kxm init first)");
       return 1;
     }
-    const supervisor = await (vnextDriveCliSeams.ensureSupervisor ?? ensureVnextSupervisor)({ env: runtime.env });
-    const result = await (vnextDriveCliSeams.runtimeRequest ?? vnextRuntimeRequest)(
+    const supervisor = await (kxmDriveCliSeams.ensureSupervisor ?? ensureKxmSupervisor)({ env: runtime.env });
+    const result = await (kxmDriveCliSeams.runtimeRequest ?? kxmRuntimeRequest)(
       supervisor,
       "GET",
       `/v1/runs/${encodeURIComponent(runId)}/drive?projectRoot=${encodeURIComponent(projectRoot)}`,
@@ -874,7 +874,7 @@ export async function cmdVnextRunReceipt(runtime: Runtime, runId: string, option
     print(runtime.io, runtime.json, { ok: true, command: "runs receipt", receipt: latest }, JSON.stringify(settlement, null, 2));
     return 0;
   } catch (error) {
-    if (error instanceof VnextConfigError) {
+    if (error instanceof KxmConfigError) {
       print(runtime.io, runtime.json, { ok: false, command: "runs receipt", error: "run_receipt_failed", issues: error.issues }, `run receipt failed: ${error.message}`);
       return 1;
     }

package/plugins/kxm/src/cli/roles.ts

@@ -17,8 +17,8 @@ import {
   resolveRoleSeat,
   type KxmRoleDefinition,
 } from "../role.ts";
-import { discoverVnextProjectRoot } from "../vnext-config.ts";
-import { ensureVnextSupervisor, vnextRuntimeRequest } from "../vnext-runtime-supervisor.ts";
+import { discoverKxmProjectRoot } from "../project-config.ts";
+import { ensureKxmSupervisor, kxmRuntimeRequest } from "../runtime-supervisor.ts";
 import { resumeWorkflowFromRuling, type WorkflowRun } from "../workflow.ts";
 import { print, type CliIo, type Runtime } from "./types.ts";
 
@@ -517,16 +517,16 @@ export async function cmdRoleResume(
 
   const effectiveRuling = ruling?.trim() || "operator_ruling: waived and resumed";
 
-  // Check if it's a vNext run
-  const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+  // Check if it's a KXM run
+  const projectRoot = discoverKxmProjectRoot(runtime.cwd);
   if (projectRoot && /^run_[a-f0-9]{32}$/i.test(runId)) {
     if (runtime.dryRun) {
-      print(runtime.io, runtime.json, { ok: true, command: "role resume", runId, ruling: effectiveRuling }, `would resume vNext run ${runId}`);
+      print(runtime.io, runtime.json, { ok: true, command: "role resume", runId, ruling: effectiveRuling }, `would resume KXM run ${runId}`);
       return 0;
     }
     try {
-      const supervisor = await ensureVnextSupervisor({ env: runtime.env });
-      const posted = await vnextRuntimeRequest(
+      const supervisor = await ensureKxmSupervisor({ env: runtime.env });
+      const posted = await kxmRuntimeRequest(
         supervisor,
         "POST",
         `/v1/runs/${encodeURIComponent(runId)}/signal?projectRoot=${encodeURIComponent(projectRoot)}`,
@@ -541,12 +541,12 @@ export async function cmdRoleResume(
         runtime.io,
         runtime.json,
         { ok: true, command: "role resume", runId, ruling: effectiveRuling, unblocked: posted.unblocked === true },
-        `Resumed vNext run ${runId} with ruling: ${effectiveRuling}\n`,
+        `Resumed KXM run ${runId} with ruling: ${effectiveRuling}\n`,
       );
       return 0;
     } catch (error) {
       const msg = error instanceof Error ? error.message : "resume_failed";
-      print(runtime.io, runtime.json, { ok: false, command: "role resume", error: "resume_failed", detail: msg }, `resume vNext run failed: ${msg}\n`);
+      print(runtime.io, runtime.json, { ok: false, command: "role resume", error: "resume_failed", detail: msg }, `resume KXM run failed: ${msg}\n`);
       return 1;
     }
   }

package/plugins/kxm/src/cli/system.ts

@@ -83,8 +83,8 @@ import {
   probeHarnessesAsync,
   runHarnessUpdate,
   type HarnessUpdateScope,
-} from "../vnext-harness.ts";
-import { vnextUserStateRoot } from "../vnext-bindings.ts";
+} from "../harness.ts";
+import { kxmUserStateRoot } from "../bindings.ts";
 import {
   print,
   printWorker,