@kontextmind/kxm 0.7.40 → 0.7.43

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { probeHarnessesAsync } from "../vnext-harness.ts";
+import { probeHarnessesAsync } from "../harness.ts";
 import { suggestWorkflowAndRoles } from "../suggest.ts";
 import {
   createGoal,
@@ -14,8 +14,8 @@ import {
   type TaskStatus,
   type TrackerType,
 } from "../task-manager.ts";
-import { discoverVnextProjectRoot } from "../vnext-config.ts";
-import { compileVnextWorkflow } from "../vnext-engine-compile.ts";
+import { discoverKxmProjectRoot } from "../project-config.ts";
+import { compileKxmWorkflow } from "../engine-compile.ts";
 import {
   createStudioServer,
   DEFAULT_STUDIO_PORT,
@@ -23,7 +23,7 @@ import {
 } from "../studio-layout.ts";
 import { readSessionTokenFromDisk } from "../commands.ts";
 import { print, type Runtime } from "./types.ts";
-import { cmdVnextRun } from "./vnext.ts";
+import { cmdKxmRun } from "./project.ts";
 
 export async function cmdSuggest(runtime: Runtime, promptParts: string[]): Promise<number> {
   try {
@@ -187,7 +187,7 @@ export async function cmdTaskRun(runtime: Runtime, taskId: string): Promise<numb
       return 1;
     }
     const workflow = task.assignedWorkflow ?? "default";
-    const exitCode = await cmdVnextRun(runtime, workflow, [task.objective]);
+    const exitCode = await cmdKxmRun(runtime, workflow, [task.objective]);
     if (exitCode === 0) {
       updateTaskStatus(runtime.cwd, taskId, "in_progress");
     }
@@ -218,7 +218,7 @@ export async function cmdTaskSync(runtime: Runtime, taskId: string): Promise<num
 
 export async function cmdStudioLayout(runtime: Runtime, workflowPath?: string | undefined): Promise<number> {
   try {
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd) ?? runtime.cwd;
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd) ?? runtime.cwd;
     let filePath = workflowPath;
     if (!filePath) {
       filePath = resolve(projectRoot, ".kxm", "workflows", "default.yaml");
@@ -267,7 +267,7 @@ steps:
 `;
     }
     const parsedYaml = parseYaml(yamlContent) as any;
-    const plan = compileVnextWorkflow({ id: workflowId, value: parsedYaml });
+    const plan = compileKxmWorkflow({ id: workflowId, value: parsedYaml });
     const layout = generateStudioLayout(plan);
     print(runtime.io, runtime.json, { ok: true, command: "studio layout", layout }, JSON.stringify(layout, null, 2));
     return 0;
@@ -317,7 +317,7 @@ export async function cmdStudioServe(
             const raw = readFileSync(targetPath, "utf8");
             const parsed = parseYaml(raw) as any;
             const wfId = basename(targetPath).replace(/\.(yaml|yml)$/, "");
-            return compileVnextWorkflow({ id: wfId, value: parsed });
+            return compileKxmWorkflow({ id: wfId, value: parsed });
           }
         } catch {
           // fallback

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

@@ -19,8 +19,8 @@ import {
   type WorkflowJournalEntry,
   type WorkflowRun,
 } from "../workflow.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 type { WorkerOutcome } from "../envelope.ts";
 import {
   print,
@@ -517,26 +517,26 @@ export async function cmdSignal(runtime: Runtime, runId: string, signalKey: stri
     return 2;
   }
   const worker = gateOf(runtime, "signal");
-  const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+  const projectRoot = discoverKxmProjectRoot(runtime.cwd);
   if (projectRoot && /^run_[a-f0-9]{32}$/i.test(runId)) {
     if (runtime.dryRun) {
-      printWorker(runtime, worker, { ok: true, command: "signal", runId, signalKey, status, summary, evidence }, "would post signal to vNext run");
+      printWorker(runtime, worker, { ok: true, command: "signal", runId, signalKey, status, summary, evidence }, "would post signal to KXM run");
       return 0;
     }
     const deliveryId = String(deliveryIdFlag || `cli-signal:${randomUUID()}`);
     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)}`,
         { signalKey, status, summary, evidence, deliveryId, ...(recoveryAction ? { action: recoveryAction } : {}) },
       );
-      printWorker(runtime, worker, { ok: true, command: "signal", runId, signalKey, status, unblocked: posted.unblocked === true, deliveryId }, "posted signal to vNext run");
+      printWorker(runtime, worker, { ok: true, command: "signal", runId, signalKey, status, unblocked: posted.unblocked === true, deliveryId }, "posted signal to KXM run");
       return 0;
     } catch (error) {
       const msg = error instanceof Error ? error.message : "signal_failed";
-      printWorker(runtime, worker, { ok: false, command: "signal", error: "signal_failed", detail: msg, deliveryId }, "signal to vNext run failed");
+      printWorker(runtime, worker, { ok: false, command: "signal", error: "signal_failed", detail: msg, deliveryId }, "signal to KXM run failed");
       return 1;
     }
   }

package/plugins/kxm/src/cli.ts

@@ -7,7 +7,7 @@
  * - Role & workflow governance (`kxm role`, `kxm workflow`, `kxm gate`, `kxm signal`)
  * - Task & goal management (`kxm goal`, `kxm task`, `kxm suggest`, `kxm studio`)
  * - Knowledge, skills, and memory (`kxm context`, `kxm skills`, `kxm memory`)
- * - vNext runtime & initialization (`kxm init`, `kxm migrate`, `kxm trust`, `kxm run`, `kxm harness`)
+ * - KXM runtime & initialization (`kxm init`, `kxm migrate`, `kxm trust`, `kxm run`, `kxm harness`)
  * - Hub, workers, and dashboard (`kxm hub`, `kxm worker`, `kxm dash`, `kxm session`, `kxm auth`)
  * - System, update, and configuration (`kxm update`, `kxm config`, `kxm completion`, `kxm improve`)
  */
@@ -24,8 +24,8 @@ import {
   AGENT_COMMANDS_MAP,
   enforceToolPolicy,
 } from "./commands.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";
 
 // Submodule imports
 import {
@@ -97,27 +97,27 @@ import {
 } from "./cli/context-skills.ts";
 
 import {
-  cmdVnextInit,
-  cmdVnextMigratePlan,
-  cmdVnextMigrateApply,
-  cmdVnextMigrateVerify,
+  cmdKxmInit,
+  cmdKxmMigratePlan,
+  cmdKxmMigrateApply,
+  cmdKxmMigrateVerify,
   cmdBackup,
   cmdRestore,
-  cmdVnextTrust,
-  cmdVnextRun,
-  cmdVnextRunStatus,
-  cmdVnextRunDrive,
-  cmdVnextRunReceipt,
-  cmdVnextRunCancel,
-  cmdVnextRunList,
+  cmdKxmTrust,
+  cmdKxmRun,
+  cmdKxmRunStatus,
+  cmdKxmRunDrive,
+  cmdKxmRunReceipt,
+  cmdKxmRunCancel,
+  cmdKxmRunList,
   cmdHarnessList,
   cmdRouteChange,
   cmdModelsScreen,
   cmdRouteList,
   cmdRouteCount,
   cmdModelInventoryRefresh,
-  cmdVnextRuntime,
-} from "./cli/vnext.ts";
+  cmdKxmRuntime,
+} from "./cli/project.ts";
 
 import {
   cmdStatus,
@@ -260,28 +260,28 @@ async function dispatchAgentCliCommand(
     }
   }
 
-  // Handle vNext run binding for workflow wait
+  // Handle KXM run binding for workflow wait
   if (toolName === "kxm_workflow_wait") {
     const runId = typeof args.runId === "string" ? args.runId : undefined;
-    const projectRoot = discoverVnextProjectRoot(runtime.cwd);
+    const projectRoot = discoverKxmProjectRoot(runtime.cwd);
     if (runId && projectRoot && /^run_[a-f0-9]{32}$/i.test(runId)) {
       if (runtime.dryRun) {
-        print(runtime.io, runtime.json, { ok: true, command: "workflow wait", runId, dryRun: true }, `would wait for signal on vNext run ${runId}`);
+        print(runtime.io, runtime.json, { ok: true, command: "workflow wait", runId, dryRun: true }, `would wait for signal on KXM run ${runId}`);
         return 0;
       }
       try {
-        const supervisor = await ensureVnextSupervisor({ env: runtime.env });
-        const result = await vnextRuntimeRequest(
+        const supervisor = await ensureKxmSupervisor({ env: runtime.env });
+        const result = await kxmRuntimeRequest(
           supervisor,
           "POST",
           `/v1/runs/${encodeURIComponent(runId)}/wait?projectRoot=${encodeURIComponent(projectRoot)}`,
           args,
         );
-        print(runtime.io, runtime.json, result, `waiting for signal on vNext run ${runId}`);
+        print(runtime.io, runtime.json, result, `waiting for signal on KXM run ${runId}`);
         return 0;
       } catch (error) {
-        const msg = error instanceof Error ? error.message : "vnext_wait_failed";
-        print(runtime.io, runtime.json, { ok: false, error: "vnext_wait_failed", detail: msg }, `vNext wait failed: ${msg}`);
+        const msg = error instanceof Error ? error.message : "wait_failed";
+        print(runtime.io, runtime.json, { ok: false, error: "wait_failed", detail: msg }, `KXM wait failed: ${msg}`);
         return 1;
       }
     }
@@ -334,14 +334,14 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
     .helpCommand("help", "Show help");
   addGlobalOptions(program);
 
-  program.command("init").description("Create, validate, or plan migration of a vNext project")
+  program.command("init").description("Create, validate, or plan migration of a KXM project")
     .option("--json", "Print machine-readable JSON")
     .option("--dry-run", "Plan without making changes")
     .option("--name <name>", "Project display name for a new project")
     .option("--project-id <id>", "Stable project ID for controlled provisioning")
     .option("--repository <id=absolute-path>", "Bind a member repository outside Git configuration", (value, previous: string[]) => [...previous, value], [])
     .action(async function initAction(this: Command, options: { name?: string; projectId?: string; repository?: string[] }) {
-      result.code = await cmdVnextInit(runtimeFrom(ctx, this), options, {
+      result.code = await cmdKxmInit(runtimeFrom(ctx, this), options, {
         maybeOfferCompletionInstall,
         maybeOfferGuideSetup,
       });
@@ -349,20 +349,20 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
 
   const migrate = addGlobalOptions(program.command("migrate").description("Plan, apply, and verify legacy JSON configuration migration"));
   migrate.helpCommand("help", "Show migrate help");
-  addGlobalOptions(migrate.command("plan").description("Compute the deterministic legacy-to-vNext migration plan without writes"))
+  addGlobalOptions(migrate.command("plan").description("Compute the deterministic legacy-to-KXM migration plan without writes"))
     .action(async function migratePlanAction(this: Command) {
-      result.code = await cmdVnextMigratePlan(runtimeFrom(ctx, this));
+      result.code = await cmdKxmMigratePlan(runtimeFrom(ctx, this));
     });
   addGlobalOptions(migrate.command("apply").description("Install a reviewed migration with a hash-linked receipt"))
     .option("--decisions <file>", "Reviewed kxm.migration-decision.v1 YAML file")
     .option("--project-id <id>", "Stable project ID for controlled provisioning")
     .option("--name <name>", "Project display name")
     .action(async function migrateApplyAction(this: Command, options: { decisions?: string; projectId?: string; name?: string }) {
-      result.code = await cmdVnextMigrateApply(runtimeFrom(ctx, this), options);
+      result.code = await cmdKxmMigrateApply(runtimeFrom(ctx, this), options);
     });
   addGlobalOptions(migrate.command("verify").description("Verify a migration receipt against current sources and target bundle"))
     .action(async function migrateVerifyAction(this: Command) {
-      result.code = await cmdVnextMigrateVerify(runtimeFrom(ctx, this));
+      result.code = await cmdKxmMigrateVerify(runtimeFrom(ctx, this));
     });
 
   addGlobalOptions(program.command("backup").description("Create a verified SQLite backup of all stores with a hashed manifest"))
@@ -376,18 +376,18 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
       result.code = await cmdRestore(runtimeFrom(ctx, this), manifest);
     });
 
-  addGlobalOptions(program.command("run").description("Create a vNext run (offline-first; no steps execute until the run engine lands)")
+  addGlobalOptions(program.command("run").description("Create a KXM run (offline-first; no steps execute until the run engine lands)")
     .argument("[workflow]", "Workflow id to run")
     .argument("[prompt...]", "Run prompt (hashed, never stored raw)")
     .action(async function runAction(this: Command, workflow: string | undefined, promptParts: string[]) {
-      result.code = await cmdVnextRun(runtimeFrom(ctx, this), workflow, promptParts);
+      result.code = await cmdKxmRun(runtimeFrom(ctx, this), workflow, promptParts);
     }));
-  const runCmd = addGlobalOptions(program.command("runs").description("Inspect vNext runs"));
+  const runCmd = addGlobalOptions(program.command("runs").description("Inspect KXM runs"));
   runCmd.helpCommand("help", "Show runs help");
   addGlobalOptions(runCmd.command("status").description("Show the projected status of a run, including durable drive receipt state (open / receipt verified / unsettled / orphaned)"))
     .argument("<runId>", "Run id")
     .action(async function runStatusAction(this: Command, runId: string) {
-      result.code = await cmdVnextRunStatus(runtimeFrom(ctx, this), runId);
+      result.code = await cmdKxmRunStatus(runtimeFrom(ctx, this), runId);
     });
   addGlobalOptions(runCmd.command("drive").description("Drive a run with an explicit model-free simulation"))
     .argument("<runId>", "Run id")
@@ -395,7 +395,7 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
     .option("--wait", "Wait until a drive receipt is recorded; exits 0 only for a VERIFIED COMPLETED settlement")
     .option("--timeout-ms <n>", "Wait timeout in milliseconds (default 60000, max 600000)")
     .action(async function runDriveAction(this: Command, runId: string, options: { simulated?: boolean; wait?: boolean; timeoutMs?: string }) {
-      result.code = await cmdVnextRunDrive(runtimeFrom(ctx, this), runId, options.simulated === true, {
+      result.code = await cmdKxmRunDrive(runtimeFrom(ctx, this), runId, options.simulated === true, {
         wait: options.wait === true,
         ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
       });
@@ -404,16 +404,16 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
     .argument("<runId>", "Run id")
     .option("--all", "Print the capped receipt list for the run")
     .action(async function runReceiptAction(this: Command, runId: string, options: { all?: boolean }) {
-      result.code = await cmdVnextRunReceipt(runtimeFrom(ctx, this), runId, { all: options.all === true });
+      result.code = await cmdKxmRunReceipt(runtimeFrom(ctx, this), runId, { all: options.all === true });
     });
   addGlobalOptions(runCmd.command("cancel").description("Durably request cancellation of a run"))
     .argument("<runId>", "Run id")
     .action(async function runCancelAction(this: Command, runId: string) {
-      result.code = await cmdVnextRunCancel(runtimeFrom(ctx, this), runId);
+      result.code = await cmdKxmRunCancel(runtimeFrom(ctx, this), runId);
     });
   addGlobalOptions(runCmd.command("list").description("List recent runs for the current project"))
     .action(async function runListAction(this: Command) {
-      result.code = await cmdVnextRunList(runtimeFrom(ctx, this));
+      result.code = await cmdKxmRunList(runtimeFrom(ctx, this));
     });
 
   const modelsCmd = addGlobalOptions(program.command("models").description("Manage model catalogs, roles, and route state"));
@@ -462,32 +462,32 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
       result.code = await cmdUpdate(runtimeFrom(ctx, this), harness, options);
     });
 
-  const runtimeCmd = addGlobalOptions(program.command("runtime").description("Manage the vNext Runtime supervisor"));
+  const runtimeCmd = addGlobalOptions(program.command("runtime").description("Manage the KXM Runtime supervisor"));
   runtimeCmd.helpCommand("help", "Show runtime help");
   addGlobalOptions(runtimeCmd.command("start").description("Start the Runtime supervisor if not running"))
     .action(async function runtimeStartAction(this: Command) {
-      result.code = await cmdVnextRuntime(runtimeFrom(ctx, this), "start");
+      result.code = await cmdKxmRuntime(runtimeFrom(ctx, this), "start");
     });
   addGlobalOptions(runtimeCmd.command("status").description("Show Runtime supervisor liveness"))
     .action(async function runtimeStatusAction(this: Command) {
-      result.code = await cmdVnextRuntime(runtimeFrom(ctx, this), "status");
+      result.code = await cmdKxmRuntime(runtimeFrom(ctx, this), "status");
     });
   addGlobalOptions(runtimeCmd.command("stop").description("Gracefully stop the Runtime supervisor"))
     .action(async function runtimeStopAction(this: Command) {
-      result.code = await cmdVnextRuntime(runtimeFrom(ctx, this), "stop");
+      result.code = await cmdKxmRuntime(runtimeFrom(ctx, this), "stop");
     });
 
-  const trust = addGlobalOptions(program.command("trust").description("Permission-diff trust review for vNext configuration"));
+  const trust = addGlobalOptions(program.command("trust").description("Permission-diff trust review for KXM configuration"));
   trust.helpCommand("help", "Show trust help");
   addGlobalOptions(trust.command("diff").description("Show the structured permission diff against a base Git revision"))
     .option("--base <revision>", "Base Git revision (default: HEAD)")
     .action(async function trustDiffAction(this: Command, options: { base?: string }) {
-      result.code = await cmdVnextTrust(runtimeFrom(ctx, this), false, options);
+      result.code = await cmdKxmTrust(runtimeFrom(ctx, this), false, options);
     });
   addGlobalOptions(trust.command("check").description("Exit non-zero when the working tree expands permissions against the base revision"))
     .option("--base <revision>", "Base Git revision (default: HEAD)")
     .action(async function trustCheckAction(this: Command, options: { base?: string }) {
-      result.code = await cmdVnextTrust(runtimeFrom(ctx, this), true, options);
+      result.code = await cmdKxmTrust(runtimeFrom(ctx, this), true, options);
     });
 
   const agent = addGlobalOptions(program.command("agent").description("Run and supervise agents"));
@@ -686,7 +686,7 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
       };
       result.code = await dispatchAgentCliCommand(runtimeFrom(ctx, this), "kxm_workflow_wait", options);
     });
-  addGlobalOptions(workflow.command("signal").description("Post a signed workflow callback or unblock a vNext run"))
+  addGlobalOptions(workflow.command("signal").description("Post a signed workflow callback or unblock a KXM run"))
     .argument("<runId>", "Workflow run ID")
     .argument("<signalKey>", "Wait signal key")
     .argument("<status>", "passed, warning, or failed")
@@ -824,7 +824,7 @@ function createProgram(ctx: CliContext, result: { code: number }): Command {
     .argument("<summary>", "Callback summary")
     .argument("[evidence...]", "required-key=evidence pairs")
     .option("--delivery-id <id>", "Stable callback delivery ID")
-    .option("--recovery-action <action>", "vNext recovery action: retry, fail, cancel, unblock")
+    .option("--recovery-action <action>", "KXM recovery action: retry, fail, cancel, unblock")
     .action(async function signalAction(this: Command, runId: string, signalKey: string, status: string, summary: string, evidence: string[], options: { deliveryId?: string; recoveryAction?: string }) {
       result.code = await cmdSignal(runtimeFrom(ctx, this), runId, signalKey, status, summary, evidence ?? [], options.deliveryId, options.recoveryAction);
     });

package/plugins/kxm/src/config.ts

@@ -261,32 +261,53 @@ export function getKxmConfigValue(config: KxmResolvedConfig, keyPath: string): u
   return current;
 }
 
-export function setKxmConfigValue(
+/** Resolve the file a scope writes, shared by set and delete. */
+export function kxmConfigFileForScope(
   repoRoot: string,
-  keyPath: string,
-  value: unknown,
-  options: { scope?: "user" | "project"; userConfigDir?: string } = {},
-): void {
-  const scope = options.scope ?? "project";
-  const targetFile = scope === "user"
-    ? join(userConfigDirectory(options.userConfigDir), "config.yaml")
+  scope: "user" | "project",
+  userConfigDir?: string,
+): string {
+  return scope === "user"
+    ? join(userConfigDirectory(userConfigDir), "config.yaml")
     : join(repoConfigDirectory(repoRoot), "config.yaml");
+}
 
-  mkdirSync(dirname(targetFile), { recursive: true });
+function configKeyParts(keyPath: string): string[] {
+  const parts = keyPath.split(".");
+  if (parts.some((part) => !part || part === "__proto__" || part === "prototype" || part === "constructor")) {
+    throw new Error("invalid config key path");
+  }
+  return parts;
+}
 
+function readConfigFile(targetFile: string): Record<string, unknown> {
   let existing: Record<string, unknown> = {};
   if (existsSync(targetFile)) {
     try {
       existing = (parse(readFileSync(targetFile, "utf8")) as Record<string, unknown>) ?? {};
     } catch {
+      // A malformed file is repaired by the next write, the same way the
+      // existing set path behaves: refuse nothing here or `set` would regress.
       existing = {};
     }
   }
+  return existing;
+}
 
-  const parts = keyPath.split(".");
-  if (parts.some((part) => !part || part === "__proto__" || part === "prototype" || part === "constructor")) {
-    throw new Error("invalid config key path");
-  }
+function writeConfigFile(targetFile: string, value: Record<string, unknown>): void {
+  mkdirSync(dirname(targetFile), { recursive: true });
+  writeFileSync(targetFile, stringify(value).trim() + "\n", "utf8");
+}
+
+export function setKxmConfigValue(
+  repoRoot: string,
+  keyPath: string,
+  value: unknown,
+  options: { scope?: "user" | "project"; userConfigDir?: string } = {},
+): void {
+  const targetFile = kxmConfigFileForScope(repoRoot, options.scope ?? "project", options.userConfigDir);
+  const existing = readConfigFile(targetFile);
+  const parts = configKeyParts(keyPath);
   let cursor = existing;
   for (let i = 0; i < parts.length - 1; i++) {
     const p = parts[i]!;
@@ -296,8 +317,42 @@ export function setKxmConfigValue(
     cursor = cursor[p] as Record<string, unknown>;
   }
   cursor[parts[parts.length - 1]!] = value;
+  writeConfigFile(targetFile, existing);
+}
 
-  writeFileSync(targetFile, stringify(existing).trim() + "\n", "utf8");
+/**
+ * Remove a key so the next scope, then the built-in default, applies.
+ *
+ * Writing `null` is not the same thing: `defaults.harness: null` reads back as a
+ * set value. "Inherit" has to delete, and empty parents are pruned so an unset
+ * does not leave a skeleton behind.
+ */
+export function deleteKxmConfigValue(
+  repoRoot: string,
+  keyPath: string,
+  options: { scope?: "user" | "project"; userConfigDir?: string } = {},
+): boolean {
+  const targetFile = kxmConfigFileForScope(repoRoot, options.scope ?? "project", options.userConfigDir);
+  if (!existsSync(targetFile)) return false;
+  const existing = readConfigFile(targetFile);
+  const parts = configKeyParts(keyPath);
+  const parents: Record<string, unknown>[] = [existing];
+  let cursor = existing;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object" || Array.isArray(next)) return false;
+    cursor = next as Record<string, unknown>;
+    parents.push(cursor);
+  }
+  const leaf = parts[parts.length - 1]!;
+  if (!Object.prototype.hasOwnProperty.call(cursor, leaf)) return false;
+  delete cursor[leaf];
+  for (let i = parents.length - 1; i > 0; i -= 1) {
+    if (Object.keys(parents[i]!).length > 0) break;
+    delete parents[i - 1]![parts[i - 1]!];
+  }
+  writeConfigFile(targetFile, existing);
+  return true;
 }
 
 export function formatKxmConfig(config: KxmResolvedConfig): string {

package/plugins/kxm/src/database.ts

@@ -12,7 +12,7 @@ import {
 } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { DatabaseSync } from "./sqlite.ts";
-import { VnextConfigError, type VnextConfigIssue } from "./vnext-config.ts";
+import { KxmConfigError, type KxmConfigIssue } from "./project-config.ts";
 
 export interface DatabaseMigrationStep {
   fromVersion: number;
@@ -61,9 +61,9 @@ export interface RestoreResult {
   restoredStores: RestoreStoreRecord[];
 }
 
-export function databaseError(code: string, file: string, message: string): VnextConfigError {
-  const issue: VnextConfigIssue = { phase: "semantic", code, file, message };
-  return new VnextConfigError([issue]);
+export function databaseError(code: string, file: string, message: string): KxmConfigError {
+  const issue: KxmConfigIssue = { phase: "semantic", code, file, message };
+  return new KxmConfigError([issue]);
 }
 
 export function checkedParent(path: string, description: string): void {

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

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { verifyArtifactExists } from "./artifacts-exist.ts";
-import type { VnextRuntimeContext } from "./vnext-runtime.ts";
+import type { KxmRuntimeContext } from "./runtime-service.ts";
 
-export interface VnextArtifactsObservation {
+export interface KxmArtifactsObservation {
   completeness: "complete";
   spawned: 0;
   pid: null;
@@ -26,7 +26,7 @@ export interface VnextArtifactsObservation {
   finishedAt: string;
 }
 
-export interface VnextArtifactsGateSeams {
+export interface KxmArtifactsGateSeams {
   afterPathChecked?: ((input: {
     path: string;
     index: number;
@@ -35,16 +35,16 @@ export interface VnextArtifactsGateSeams {
   }) => void) | undefined;
 }
 
-export const vnextArtifactsGateSeams: VnextArtifactsGateSeams = {};
+export const kxmArtifactsGateSeams: KxmArtifactsGateSeams = {};
 
 /**
  * Check every pinned path under control `.kxm/assets`. Normal helper failures
  * are complete failed facts. Exceptions after checks begin must propagate.
  */
 export function evaluateArtifactsGate(
-  context: VnextRuntimeContext,
+  context: KxmRuntimeContext,
   definition: { readonly kind: "artifacts-exist"; readonly paths: readonly string[] },
-): VnextArtifactsObservation {
+): KxmArtifactsObservation {
   const root = join(context.projectRoot, ".kxm", "assets");
   const startedAt = new Date().toISOString();
   const startTime = process.hrtime.bigint();
@@ -55,7 +55,7 @@ export function evaluateArtifactsGate(
     checkedCount += 1;
     const result = verifyArtifactExists(root, join(root, path));
     if (!result.ok) failedCount += 1;
-    vnextArtifactsGateSeams.afterPathChecked?.({ path, index, checkedCount, failedCount });
+    kxmArtifactsGateSeams.afterPathChecked?.({ path, index, checkedCount, failedCount });
   }
 
   const elapsedNs = process.hrtime.bigint() - startTime;