@kontextmind/kxm 0.7.40 → 0.7.44

package/plugins/kxm/src/gate-hash.ts

@@ -0,0 +1,10 @@
+import { kxmCanonicalJson, type JsonValue } from "./project-config.ts";
+import { kxmSha256 } from "./engine-plan.ts";
+
+export function gateDefinitionHash(id: string, definition: JsonValue): string {
+  return kxmSha256(kxmCanonicalJson({ id, ...(definition as object) } as JsonValue));
+}
+
+export function gateRegistryHash(registryValue: JsonValue): string {
+  return kxmSha256(kxmCanonicalJson(registryValue));
+}

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

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { win32 as win32Path } from "node:path";
-import { defaultSpawn } from "./vnext-oneshot-process.ts";
+import { defaultSpawn } from "./oneshot-process.ts";
 
 export const DEFAULT_HARNESS = "pi";
 export type HarnessMode = "headless" | "either";

package/plugins/kxm/src/hub.ts

@@ -2166,7 +2166,7 @@ export function createMeshHub(options: MeshHubOptions = {}): MeshHub {
         const current = requireAgent(request, agentId);
         requireProjectAuth(request, current.project);
         const presenceOnly = url.searchParams.get("presenceOnly") === "true";
-        if (presenceOnly && current.model !== "kxm-tui") {
+        if (presenceOnly && current.model !== "tui") {
           throw new ProtocolError(403, "presence-only streams are reserved for metadata observers", "presence_stream_forbidden");
         }
         response.writeHead(200, {

package/plugins/kxm/src/init-guide-setup.ts

@@ -7,7 +7,7 @@
  * first candidate whose harness is installed AND authenticated wins. No
  * candidate is admitted without an authenticated harness (fail closed).
  *
- * This module writes only current vNext project resources:
+ * This module writes only current KXM project resources:
  *   - `.kxm/agents/<role-slug>.yaml`   (kxm.agent.v1)
  *   - `.kxm/workflows/<slug>.yaml`     (kxm.workflow.v1)
  * It never writes retired legacy authority (`.kxm/config`, retired
@@ -18,7 +18,7 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { stringify } from "yaml";
-import { NATIVE_HARNESS_PROVIDERS, type HarnessInventory } from "./vnext-harness.ts";
+import { NATIVE_HARNESS_PROVIDERS, type HarnessInventory } from "./harness.ts";
 
 export interface GuideCandidate {
   readonly vendor: string;
@@ -482,7 +482,7 @@ function workflowDocument(workflow: GuideWorkflow): Record<string, unknown> {
 }
 
 /**
- * Render the planned vNext resource files (`.kxm/agents/*.yaml`,
+ * Render the planned KXM resource files (`.kxm/agents/*.yaml`,
  * `.kxm/workflows/*.yaml`). Pure: no disk access.
  */
 export function renderGuideSetupFiles(projectRoot: string, plan: GuideSetupPlan): GuideSetupFile[] {

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

@@ -2,60 +2,60 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { basename, join } from "node:path";
 import {
-  VnextConfigError,
+  KxmConfigError,
   discoverGitRoot,
-  loadVnextProject,
+  loadKxmProject,
   assertNoRegisteredGates,
-  planVnextInitialization,
+  planKxmInitialization,
   type JsonObject,
-  type VnextConfigIssue,
-  type VnextConfigOptions,
-  type VnextInitializationPlan,
-} from "./vnext-config.ts";
+  type KxmConfigIssue,
+  type KxmConfigOptions,
+  type KxmInitializationPlan,
+} from "./project-config.ts";
 import {
-  planVnextLocalBindings,
-  readVnextLocalBindings,
-  withVnextLocalBindingLock,
-  writeVnextLocalBindings,
-  type VnextLocalBindingLock,
-  type VnextLocalBindingStoreOptions,
-} from "./vnext-bindings.ts";
+  planKxmLocalBindings,
+  readKxmLocalBindings,
+  withKxmLocalBindingLock,
+  writeKxmLocalBindings,
+  type KxmLocalBindingLock,
+  type KxmLocalBindingStoreOptions,
+} from "./bindings.ts";
 import {
-  commitVnextInitTransaction,
-  hasVnextInitTransaction,
-  inspectVnextInitTransaction,
-  planVnextTemplateRepair,
-  prepareAndApplyVnextCreate,
-  prepareAndApplyVnextRepair,
-  resumeVnextInitTransaction,
-  type VnextRepairRuntimeOptions,
-  type VnextTemplateRepairPlan,
-} from "./vnext-repair.ts";
+  commitKxmInitTransaction,
+  hasKxmInitTransaction,
+  inspectKxmInitTransaction,
+  planKxmTemplateRepair,
+  prepareAndApplyKxmCreate,
+  prepareAndApplyKxmRepair,
+  resumeKxmInitTransaction,
+  type KxmRepairRuntimeOptions,
+  type KxmTemplateRepairPlan,
+} from "./repair.ts";
 import {
-  CURRENT_VNEXT_TEMPLATE_VARIANT,
-  renderVnextTemplate,
-  type VnextTemplateVariant,
-} from "./vnext-template.ts";
+  CURRENT_KXM_TEMPLATE_VARIANT,
+  renderKxmTemplate,
+  type KxmTemplateVariant,
+} from "./template.ts";
 
-export interface VnextInitOptions extends VnextConfigOptions {
+export interface KxmInitOptions extends KxmConfigOptions {
   projectId?: string;
   projectName?: string;
   dryRun?: boolean;
   localStateRoot?: string;
   /** Test/future-template injection; the CLI always uses the current built-in variant. */
-  templateVariant?: VnextTemplateVariant;
+  templateVariant?: KxmTemplateVariant;
   /** Fault injection used by crash-recovery tests. */
   testFaultAt?: "prepared" | "first-resource" | "provenance" | "verified";
 }
 
-export interface VnextInitResult {
+export interface KxmInitResult {
   action: "planned" | "created" | "joined" | "repaired" | "resumed" | "validated";
-  plan: VnextInitializationPlan;
+  plan: KxmInitializationPlan;
   projectRoot?: string;
   configRevision?: string;
   localBindingFile?: string;
   bindingsChanged?: boolean;
-  repairPlan?: VnextTemplateRepairPlan;
+  repairPlan?: KxmTemplateRepairPlan;
   resumePending?: boolean;
   transactionKind?: "create" | "repair";
   files: readonly string[];
@@ -63,14 +63,14 @@ export interface VnextInitResult {
 
 const PROJECT_ID = /^prj_[A-Za-z0-9][A-Za-z0-9_-]{5,127}$/;
 
-function initIssue(code: string, file: string, message: string): VnextConfigIssue {
+function initIssue(code: string, file: string, message: string): KxmConfigIssue {
   return { phase: "discovery", code, file, message };
 }
 
 function normalizedProjectName(root: string, requested?: string): string {
   const name = (requested ?? basename(root) ?? "KXM Project").trim();
   if (name.length < 1 || name.length > 120 || /[\u0000\r\n]/.test(name)) {
-    throw new VnextConfigError([initIssue("project_name_invalid", ".kxm/project.yaml", "project name must contain 1-120 characters on one line")]);
+    throw new KxmConfigError([initIssue("project_name_invalid", ".kxm/project.yaml", "project name must contain 1-120 characters on one line")]);
   }
   return name;
 }
@@ -78,12 +78,12 @@ function normalizedProjectName(root: string, requested?: string): string {
 function generatedProjectId(requested?: string): string {
   const id = requested?.trim() || `prj_${randomUUID().replaceAll("-", "")}`;
   if (!PROJECT_ID.test(id) || id.length > 144) {
-    throw new VnextConfigError([initIssue("project_id_invalid", ".kxm/project.yaml", "project ID must satisfy the kxm.project.v1 opaque ID grammar and use the prj_ prefix")]);
+    throw new KxmConfigError([initIssue("project_id_invalid", ".kxm/project.yaml", "project ID must satisfy the kxm.project.v1 opaque ID grammar and use the prj_ prefix")]);
   }
   return id;
 }
 
-function configOptions(options: VnextInitOptions, repositoryBindings: Readonly<Record<string, string>>): VnextConfigOptions {
+function configOptions(options: KxmInitOptions, repositoryBindings: Readonly<Record<string, string>>): KxmConfigOptions {
   assertNoRegisteredGates(options);
   return {
     ...(options.schemasDir === undefined ? {} : { schemasDir: options.schemasDir }),
@@ -94,17 +94,17 @@ function configOptions(options: VnextInitOptions, repositoryBindings: Readonly<R
 }
 
 function repairOptions(
-  options: VnextInitOptions,
+  options: KxmInitOptions,
   repositoryBindings: Readonly<Record<string, string>>,
-): VnextRepairRuntimeOptions {
+): KxmRepairRuntimeOptions {
   return {
     ...configOptions(options, repositoryBindings),
-    templateVariant: options.templateVariant ?? CURRENT_VNEXT_TEMPLATE_VARIANT,
+    templateVariant: options.templateVariant ?? CURRENT_KXM_TEMPLATE_VARIANT,
     ...(options.testFaultAt === undefined ? {} : { testFaultAt: options.testFaultAt }),
   };
 }
 
-function bindingStoreOptions(options: VnextInitOptions): VnextLocalBindingStoreOptions {
+function bindingStoreOptions(options: KxmInitOptions): KxmLocalBindingStoreOptions {
   return {
     ...(options.localStateRoot === undefined ? {} : { stateRoot: options.localStateRoot }),
     ...(options.schemasDir === undefined ? {} : { schemasDir: options.schemasDir }),
@@ -119,17 +119,17 @@ function memberRepositoryIds(project: JsonObject): Set<string> {  const reposito
   }));
 }
 
-function completedPlan(projectRoot: string, options: VnextConfigOptions): VnextInitializationPlan {
-  return planVnextInitialization(projectRoot, options);
+function completedPlan(projectRoot: string, options: KxmConfigOptions): KxmInitializationPlan {
+  return planKxmInitialization(projectRoot, options);
 }
 
 function finalizeBindingUpdate(
-  bundle: ReturnType<typeof loadVnextProject>,
-  persisted: ReturnType<typeof readVnextLocalBindings>,
+  bundle: ReturnType<typeof loadKxmProject>,
+  persisted: ReturnType<typeof readKxmLocalBindings>,
   allBindings: Readonly<Record<string, string>>,
   explicitBindings: Readonly<Record<string, string>>,
-  storeOptions: VnextLocalBindingStoreOptions,
-  mutationLock: VnextLocalBindingLock | undefined,
+  storeOptions: KxmLocalBindingStoreOptions,
+  mutationLock: KxmLocalBindingLock | undefined,
   dryRun: boolean,
 ): { localBindingFile?: string; bindingsChanged?: boolean } {
   const memberIds = validateBindingIdentities(bundle, persisted, explicitBindings);
@@ -139,20 +139,20 @@ function finalizeBindingUpdate(
   const memberBindings = Object.fromEntries(Object.entries(allBindings)
     .filter(([repositoryId]) => memberIds.has(repositoryId)));
   const projectId = String(bundle.project.value.id);
-  const bindingPlan = planVnextLocalBindings(bundle.projectRoot, projectId, memberBindings, storeOptions);
+  const bindingPlan = planKxmLocalBindings(bundle.projectRoot, projectId, memberBindings, storeOptions);
   if (dryRun) return { localBindingFile: bindingPlan.file, bindingsChanged: bindingPlan.written };
   if (bindingPlan.written && !mutationLock) throw new Error("project mutation lock is required to persist repository bindings");
   const result = bindingPlan.written
-    ? writeVnextLocalBindings(bundle.projectRoot, projectId, memberBindings, storeOptions, mutationLock)
+    ? writeKxmLocalBindings(bundle.projectRoot, projectId, memberBindings, storeOptions, mutationLock)
     : bindingPlan;
   return { localBindingFile: result.file, bindingsChanged: result.written };
 }
 
 function plannedRepairResult(
-  plan: VnextInitializationPlan,
+  plan: KxmInitializationPlan,
   projectRoot: string,
-  repairPlan?: VnextTemplateRepairPlan,
-): VnextInitResult {
+  repairPlan?: KxmTemplateRepairPlan,
+): KxmInitResult {
   return {
     action: "planned",
     plan,
@@ -163,23 +163,23 @@ function plannedRepairResult(
 }
 
 function validateBindingIdentities(
-  bundle: ReturnType<typeof loadVnextProject>,
-  persisted: ReturnType<typeof readVnextLocalBindings>,
+  bundle: ReturnType<typeof loadKxmProject>,
+  persisted: ReturnType<typeof readKxmLocalBindings>,
   explicit: Readonly<Record<string, string>>,
 ): Set<string> {
   const projectId = String(bundle.project.value.id);
   if (persisted && persisted.projectId !== projectId) {
-    throw new VnextConfigError([initIssue("local_binding_project_id_mismatch", "Runtime-local repository bindings", "binding record belongs to a different project identity")]);
+    throw new KxmConfigError([initIssue("local_binding_project_id_mismatch", "Runtime-local repository bindings", "binding record belongs to a different project identity")]);
   }
   const memberIds = memberRepositoryIds(bundle.project.value);
   for (const repositoryId of Object.keys(persisted?.repositories ?? {})) {
     if (!memberIds.has(repositoryId)) {
-      throw new VnextConfigError([initIssue("local_binding_repository_invalid", "Runtime-local repository bindings", `persisted binding ${repositoryId} is not a member repository`)]);
+      throw new KxmConfigError([initIssue("local_binding_repository_invalid", "Runtime-local repository bindings", `persisted binding ${repositoryId} is not a member repository`)]);
     }
   }
   for (const repositoryId of Object.keys(explicit)) {
     if (!memberIds.has(repositoryId)) {
-      throw new VnextConfigError([initIssue("local_binding_repository_invalid", "Runtime-local repository bindings", `explicit binding ${repositoryId} is not a member repository`)]);
+      throw new KxmConfigError([initIssue("local_binding_repository_invalid", "Runtime-local repository bindings", `explicit binding ${repositoryId} is not a member repository`)]);
     }
   }
   return memberIds;
@@ -190,15 +190,15 @@ function validateBindingIdentities(
  * provenance-backed conflict-free template repair, join with local member
  * bindings, or return a non-mutating migration/conflict plan.
  */
-function initializeVnextProjectAtGitRoot(
+function initializeKxmProjectAtGitRoot(
   start: string,
   gitRoot: string,
-  options: VnextInitOptions,
-  mutationLock?: VnextLocalBindingLock,
-): VnextInitResult {
+  options: KxmInitOptions,
+  mutationLock?: KxmLocalBindingLock,
+): KxmInitResult {
   const storeOptions = bindingStoreOptions(options);
   const persisted = existsSync(join(gitRoot, ".kxm", "project.yaml"))
-    ? readVnextLocalBindings(gitRoot, storeOptions)
+    ? readKxmLocalBindings(gitRoot, storeOptions)
     : undefined;
   const repositoryBindings = Object.fromEntries([
     ...Object.entries(persisted?.repositories ?? {}),
@@ -207,13 +207,13 @@ function initializeVnextProjectAtGitRoot(
   const loaderOptions = configOptions(options, repositoryBindings);
   const transactionOptions = repairOptions(options, repositoryBindings);
 
-  if (hasVnextInitTransaction(gitRoot)) {
-    const operation = inspectVnextInitTransaction(gitRoot, options.schemasDir);
-    const plan = planVnextInitialization(start, loaderOptions);
+  if (hasKxmInitTransaction(gitRoot)) {
+    const operation = inspectKxmInitTransaction(gitRoot, options.schemasDir);
+    const plan = planKxmInitialization(start, loaderOptions);
     if (!operation) {
       if (options.dryRun) return { action: "planned", plan, projectRoot: gitRoot, resumePending: true, files: [] };
       if (!mutationLock) throw new Error("project mutation lock is required to clean an empty transaction");
-      resumeVnextInitTransaction(gitRoot, transactionOptions);
+      resumeKxmInitTransaction(gitRoot, transactionOptions);
     } else if (options.dryRun) {
       return {
         action: "planned",
@@ -226,13 +226,13 @@ function initializeVnextProjectAtGitRoot(
     } else {
       if (!mutationLock) throw new Error("project mutation lock is required to resume initialization");
       if (options.projectId !== undefined && options.projectId !== operation.projectId) {
-        throw new VnextConfigError([initIssue("resume_project_id_mismatch", "--project-id", "requested project ID differs from the pinned initialization transaction")]);
+        throw new KxmConfigError([initIssue("resume_project_id_mismatch", "--project-id", "requested project ID differs from the pinned initialization transaction")]);
       }
       if (options.projectName !== undefined && options.projectName !== operation.projectName) {
-        throw new VnextConfigError([initIssue("resume_project_name_mismatch", "--name", "requested project name differs from the pinned initialization transaction")]);
+        throw new KxmConfigError([initIssue("resume_project_name_mismatch", "--name", "requested project name differs from the pinned initialization transaction")]);
       }
       if (operation.kind === "repair" && Object.keys(options.repositoryBindings ?? {}).length > 0) {
-        const currentBundle = loadVnextProject(gitRoot, loaderOptions);
+        const currentBundle = loadKxmProject(gitRoot, loaderOptions);
         finalizeBindingUpdate(
           currentBundle,
           persisted,
@@ -243,7 +243,7 @@ function initializeVnextProjectAtGitRoot(
           false,
         );
       }
-      const result = resumeVnextInitTransaction(gitRoot, transactionOptions);
+      const result = resumeKxmInitTransaction(gitRoot, transactionOptions);
       if (!result) throw new Error("initialization transaction disappeared while holding the project lock");
       const bindingResult = finalizeBindingUpdate(
         result.bundle,
@@ -254,7 +254,7 @@ function initializeVnextProjectAtGitRoot(
         mutationLock,
         false,
       );
-      commitVnextInitTransaction(gitRoot, options.schemasDir);
+      commitKxmInitTransaction(gitRoot, options.schemasDir);
       return {
         action: "resumed",
         plan: completedPlan(gitRoot, loaderOptions),
@@ -267,24 +267,24 @@ function initializeVnextProjectAtGitRoot(
     }
   }
 
-  const plan = planVnextInitialization(start, loaderOptions);
+  const plan = planKxmInitialization(start, loaderOptions);
   if (plan.mode === "migrate") {
     return { action: "planned", plan, ...(plan.projectRoot ? { projectRoot: plan.projectRoot } : {}), files: [] };
   }
 
   if (plan.mode === "repair") {
     const projectRoot = plan.projectRoot ?? gitRoot;
-    let templateRepair: VnextTemplateRepairPlan | undefined;
+    let templateRepair: KxmTemplateRepairPlan | undefined;
     try {
-      templateRepair = planVnextTemplateRepair(projectRoot, transactionOptions);
+      templateRepair = planKxmTemplateRepair(projectRoot, transactionOptions);
     } catch (error) {
-      if (!(error instanceof VnextConfigError)) throw error;
+      if (!(error instanceof KxmConfigError)) throw error;
       return plannedRepairResult({ ...plan, issues: [...plan.issues, ...error.issues] }, projectRoot);
     }
     if (!templateRepair?.canApply) return plannedRepairResult(plan, projectRoot, templateRepair);
     if (options.dryRun) return plannedRepairResult(plan, projectRoot, templateRepair);
     if (Object.keys(options.repositoryBindings ?? {}).length > 0) {
-      const blockedRepair: VnextTemplateRepairPlan = {
+      const blockedRepair: KxmTemplateRepairPlan = {
         ...templateRepair,
         canApply: false,
         issues: [...templateRepair.issues, initIssue(
@@ -296,7 +296,7 @@ function initializeVnextProjectAtGitRoot(
       return plannedRepairResult(plan, projectRoot, blockedRepair);
     }
     if (!mutationLock) throw new Error("project mutation lock is required to apply template repair");
-    const repaired = prepareAndApplyVnextRepair(templateRepair, transactionOptions);
+    const repaired = prepareAndApplyKxmRepair(templateRepair, transactionOptions);
     const bindingResult = finalizeBindingUpdate(
       repaired.bundle,
       persisted,
@@ -306,7 +306,7 @@ function initializeVnextProjectAtGitRoot(
       mutationLock,
       false,
     );
-    commitVnextInitTransaction(projectRoot, options.schemasDir);
+    commitKxmInitTransaction(projectRoot, options.schemasDir);
     return {
       action: "repaired",
       plan: completedPlan(projectRoot, loaderOptions),
@@ -320,8 +320,8 @@ function initializeVnextProjectAtGitRoot(
 
   if (plan.mode === "ready") {
     const projectRoot = plan.projectRoot ?? gitRoot;
-    const bundle = loadVnextProject(projectRoot, loaderOptions);
-    const templateRepair = planVnextTemplateRepair(projectRoot, transactionOptions);
+    const bundle = loadKxmProject(projectRoot, loaderOptions);
+    const templateRepair = planKxmTemplateRepair(projectRoot, transactionOptions);
     if (templateRepair?.changesRequired) {
       if (!templateRepair.canApply || options.dryRun) return plannedRepairResult(plan, projectRoot, templateRepair);
       if (!mutationLock) throw new Error("project mutation lock is required to apply template repair");
@@ -334,7 +334,7 @@ function initializeVnextProjectAtGitRoot(
         mutationLock,
         false,
       );
-      const repaired = prepareAndApplyVnextRepair(templateRepair, transactionOptions);
+      const repaired = prepareAndApplyKxmRepair(templateRepair, transactionOptions);
       finalizeBindingUpdate(
         repaired.bundle,
         persisted,
@@ -344,7 +344,7 @@ function initializeVnextProjectAtGitRoot(
         mutationLock,
         false,
       );
-      commitVnextInitTransaction(projectRoot, options.schemasDir);
+      commitKxmInitTransaction(projectRoot, options.schemasDir);
       return {
         action: "repaired",
         plan: completedPlan(projectRoot, loaderOptions),
@@ -386,19 +386,19 @@ function initializeVnextProjectAtGitRoot(
   }
 
   if (plan.projectRoot !== gitRoot) {
-    throw new VnextConfigError([initIssue("git_root_required", ".", "kxm init must run inside the authoritative Git worktree")]);
+    throw new KxmConfigError([initIssue("git_root_required", ".", "kxm init must run inside the authoritative Git worktree")]);
   }
   const projectId = generatedProjectId(options.projectId);
   const projectName = normalizedProjectName(gitRoot, options.projectName);
-  const rendered = renderVnextTemplate(projectId, projectName, options.templateVariant ?? CURRENT_VNEXT_TEMPLATE_VARIANT);
+  const rendered = renderKxmTemplate(projectId, projectName, options.templateVariant ?? CURRENT_KXM_TEMPLATE_VARIANT);
   const files = [...rendered.files.keys()];
   if (options.dryRun) return { action: "planned", plan, projectRoot: gitRoot, files };
   if (!mutationLock) throw new Error("project mutation lock is required to create configuration");
   if (existsSync(join(gitRoot, ".kxm"))) {
-    throw new VnextConfigError([initIssue("workspace_changed", ".kxm", "workspace changed after planning; existing .kxm state was not overwritten")]);
+    throw new KxmConfigError([initIssue("workspace_changed", ".kxm", "workspace changed after planning; existing .kxm state was not overwritten")]);
   }
-  const created = prepareAndApplyVnextCreate(gitRoot, rendered, transactionOptions);
-  commitVnextInitTransaction(gitRoot, options.schemasDir);
+  const created = prepareAndApplyKxmCreate(gitRoot, rendered, transactionOptions);
+  commitKxmInitTransaction(gitRoot, options.schemasDir);
   return {
     action: "created",
     plan: completedPlan(gitRoot, loaderOptions),
@@ -408,23 +408,23 @@ function initializeVnextProjectAtGitRoot(
   };
 }
 
-export function initializeVnextProject(start = process.cwd(), options: VnextInitOptions = {}): VnextInitResult {
+export function initializeKxmProject(start = process.cwd(), options: KxmInitOptions = {}): KxmInitResult {
   assertNoRegisteredGates(options);
   const gitRoot = discoverGitRoot(start);
   if (!gitRoot) {
-    throw new VnextConfigError([initIssue("git_root_required", ".", "kxm init must run inside the authoritative Git worktree")]);
+    throw new KxmConfigError([initIssue("git_root_required", ".", "kxm init must run inside the authoritative Git worktree")]);
   }
   if (options.projectId !== undefined) generatedProjectId(options.projectId);
   if (options.projectName !== undefined) normalizedProjectName(gitRoot, options.projectName);
-  if (options.dryRun) return initializeVnextProjectAtGitRoot(start, gitRoot, options);
+  if (options.dryRun) return initializeKxmProjectAtGitRoot(start, gitRoot, options);
 
-  const preflight = initializeVnextProjectAtGitRoot(start, gitRoot, { ...options, dryRun: true });
+  const preflight = initializeKxmProjectAtGitRoot(start, gitRoot, { ...options, dryRun: true });
   const mutationRequired = preflight.resumePending === true
     || preflight.plan.mode === "create"
     || (preflight.repairPlan?.canApply === true
       && !(preflight.plan.mode === "repair" && Object.keys(options.repositoryBindings ?? {}).length > 0))
     || (Object.keys(options.repositoryBindings ?? {}).length > 0 && preflight.plan.mode === "ready");
-  if (!mutationRequired) return initializeVnextProjectAtGitRoot(start, gitRoot, options);
+  if (!mutationRequired) return initializeKxmProjectAtGitRoot(start, gitRoot, options);
   const storeOptions = bindingStoreOptions(options);
-  return withVnextLocalBindingLock(gitRoot, storeOptions, (lock) => initializeVnextProjectAtGitRoot(start, gitRoot, options, lock));
+  return withKxmLocalBindingLock(gitRoot, storeOptions, (lock) => initializeKxmProjectAtGitRoot(start, gitRoot, options, lock));
 }

package/plugins/kxm/src/kxm-install-kind.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { canonicalHostPath, sameHostPath } from "./vnext-bindings.ts";
+import { canonicalHostPath, sameHostPath } from "./bindings.ts";
 
 export interface InstallProbe {
   moduleDir: string;

package/plugins/kxm/src/kxm-update-config.ts

@@ -6,10 +6,10 @@ import {
   KxmUpdateConfigError,
   type KxmUpdateConfig,
 } from "./kxm-update.ts";
-import { vnextUserStateRoot } from "./vnext-bindings.ts";
+import { kxmUserStateRoot } from "./bindings.ts";
 
 export function loadKxmUpdateConfig(env: NodeJS.ProcessEnv = process.env): KxmUpdateConfig {
-  const path = join(vnextUserStateRoot({ env }), "update.yaml");
+  const path = join(kxmUserStateRoot({ env }), "update.yaml");
   if (!existsSync(path)) return { schema: KXM_UPDATE_SCHEMA, auto: false, source: "github" };
   let parsed: unknown;
   try {

package/plugins/kxm/src/local-snapshot.ts

@@ -45,7 +45,7 @@ export interface MeshTuiPlan {
 export type MeshTuiOpenMessage = Pick<MessageRecord, "id" | "status" | "fromName" | "toName" | "delivery" | "createdAt" | "correlationId">;
 
 export interface LocalMeshSnapshot {
-  source?: "legacy" | "vnext" | "both" | undefined;
+  source?: "legacy" | "runtime" | "both" | undefined;
   agents: AgentRecord[];
   openMessages: MeshTuiOpenMessage[];
   openMessageTotal: number;
@@ -205,12 +205,12 @@ export function resolveKxmSnapshotPaths(cwd: string, env: NodeJS.ProcessEnv = pr
   return { dataPath, stateDir };
 }
 
-function resolveVnextStateRoot(
+function resolveKxmStateRoot(
   stateDir: string,
-  options?: { env?: NodeJS.ProcessEnv; vnextStateRoot?: string },
+  options?: { env?: NodeJS.ProcessEnv; kxmStateRoot?: string },
 ): string | undefined {
-  if (options?.vnextStateRoot && existsSync(options.vnextStateRoot)) {
-    return resolve(options.vnextStateRoot);
+  if (options?.kxmStateRoot && existsSync(options.kxmStateRoot)) {
+    return resolve(options.kxmStateRoot);
   }
   if (existsSync(join(stateDir, "runtime", "registry.db")) || existsSync(join(stateDir, "runtime", "projects"))) {
     return stateDir;
@@ -239,7 +239,7 @@ function resolveVnextStateRoot(
 export function loadLocalMeshSnapshot(
   dataPath: string,
   stateDir: string,
-  options?: { env?: NodeJS.ProcessEnv; projectRoot?: string; vnextStateRoot?: string },
+  options?: { env?: NodeJS.ProcessEnv; projectRoot?: string; kxmStateRoot?: string },
 ): LocalMeshSnapshot {
   let hasLegacy = false;
   let agents: AgentRecord[] = [];
@@ -264,20 +264,20 @@ export function loadLocalMeshSnapshot(
     }
   }
 
-  // vNext discovery
-  let hasVnext = false;
-  const vnextRuns: MeshTuiRun[] = [];
-  let vnextRunTotal = 0;
-  const vnextStateRoot = resolveVnextStateRoot(stateDir, options);
-  if (vnextStateRoot) {
-    const runtimeDir = join(vnextStateRoot, "runtime");
+  // KXM discovery
+  let hasKxm = false;
+  const kxmRuns: MeshTuiRun[] = [];
+  let kxmRunTotal = 0;
+  const kxmStateRoot = resolveKxmStateRoot(stateDir, options);
+  if (kxmStateRoot) {
+    const runtimeDir = join(kxmStateRoot, "runtime");
     const registryDbPath = join(runtimeDir, "registry.db");
     const projectsDir = join(runtimeDir, "projects");
 
     const projectKeys = new Set<string>();
 
     if (existsSync(registryDbPath)) {
-      hasVnext = true;
+      hasKxm = true;
       try {
         const regDb = new DatabaseSync(registryDbPath, { readOnly: true });
         try {
@@ -305,7 +305,7 @@ export function loadLocalMeshSnapshot(
     for (const key of projectKeys) {
       const eventDbPath = join(projectsDir, key, "run-events.db");
       if (existsSync(eventDbPath)) {
-        hasVnext = true;
+        hasKxm = true;
         try {
           const eventDb = new DatabaseSync(eventDbPath, { readOnly: true });
           try {
@@ -322,9 +322,9 @@ export function loadLocalMeshSnapshot(
               updated_at: string;
             }>;
             const countRow = eventDb.prepare("SELECT COUNT(*) AS total FROM runs").get() as { total: number } | undefined;
-            vnextRunTotal += Number(countRow?.total ?? runRows.length);
+            kxmRunTotal += Number(countRow?.total ?? runRows.length);
             for (const r of runRows) {
-              vnextRuns.push({
+              kxmRuns.push({
                 id: r.run_id,
                 status: r.status,
                 definitionId: r.workflow_id,
@@ -360,7 +360,7 @@ export function loadLocalMeshSnapshot(
   // Combine runs
   const combinedRuns = [
     ...legacyRuns.map((run) => summarizeMeshRun(run)),
-    ...vnextRuns,
+    ...kxmRuns,
   ];
   const seenIds = new Set<string>();
   const uniqueRuns: MeshTuiRun[] = [];
@@ -376,14 +376,14 @@ export function loadLocalMeshSnapshot(
     return bt - at;
   });
   const runs = uniqueRuns.slice(0, 16);
-  const runTotal = legacyRunTotal + vnextRunTotal;
+  const runTotal = legacyRunTotal + kxmRunTotal;
 
   // Source determination
-  let source: "legacy" | "vnext" | "both";
-  if (hasLegacy && hasVnext) {
+  let source: "legacy" | "runtime" | "both";
+  if (hasLegacy && hasKxm) {
     source = "both";
-  } else if (hasVnext) {
-    source = "vnext";
+  } else if (hasKxm) {
+    source = "runtime";
   } else {
     source = "legacy";
   }

package/plugins/kxm/src/mcp-server.ts

@@ -8,7 +8,7 @@ import { AGENT_COMMANDS_MAP, enforceToolPolicy, getMcpTools, reconcileInbox } fr
 import { deliverInboxNotification } from "./inbox.ts";
 import type { HubEvent, MessageRecord } from "./protocol.ts";
 
-const VERSION = "0.7.40";
+const VERSION = "0.7.44";
 const inbox = new Map<string, MessageRecord>();
 const notifiedInbox = new Set<string>();
 let meshClient: HubClient | undefined;