@kontextmind/kxm 0.7.40 → 0.7.43

package/plugins/kxm/dist/server.js

@@ -10966,12 +10966,12 @@ var DatabaseSync = class {
   }
 };
 
-// plugins/kxm/src/vnext-config.ts
+// plugins/kxm/src/project-config.ts
 import { basename as basename2, dirname as dirname3, extname as extname2, isAbsolute, join as join4, relative, resolve as resolve3, sep } from "node:path";
 
 // plugins/kxm/src/restricted-yaml.mjs
 var import_yaml3 = __toESM(require_dist(), 1);
-var VNEXT_YAML_LIMITS = Object.freeze({
+var KXM_YAML_LIMITS = Object.freeze({
   maxDocumentBytes: 256 * 1024,
   maxDepth: 32,
   maxScalarBytes: 64 * 1024,
@@ -10980,7 +10980,7 @@ var VNEXT_YAML_LIMITS = Object.freeze({
   maxKeys: 8192
 });
 
-// plugins/kxm/src/vnext-template.ts
+// plugins/kxm/src/template.ts
 var import_yaml4 = __toESM(require_dist(), 1);
 
 // plugins/kxm/src/repo-root.ts
@@ -11002,10 +11002,10 @@ function findKxmRepoRoot(fromUrl = import.meta.url) {
   );
 }
 
-// plugins/kxm/src/vnext-oneshot-process.ts
+// plugins/kxm/src/oneshot-process.ts
 var OUTPUT_LIMIT = 8 * 1024 * 1024;
 
-// plugins/kxm/src/vnext-harness.ts
+// plugins/kxm/src/harness.ts
 var NATIVE_HARNESS_PROVIDERS = Object.freeze({
   claude: "anthropic",
   codex: "openai",
@@ -11370,20 +11370,20 @@ var WIN_NPM_INNER_EXE = Object.freeze({
   claude: Object.freeze(["node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"])
 });
 
-// plugins/kxm/src/vnext-config.ts
-var VnextConfigError = class extends Error {
+// plugins/kxm/src/project-config.ts
+var KxmConfigError = class extends Error {
   issues;
   constructor(issues) {
     const sorted = sortIssues(issues);
     super(sorted.map((issue) => `${issue.file}: ${issue.code}: ${issue.message}`).join("\n"));
-    this.name = "VnextConfigError";
+    this.name = "KxmConfigError";
     this.issues = sorted;
   }
 };
-function defaultVnextSchemaDir() {
-  return join4(findKxmRepoRoot(import.meta.url), "schemas", "vnext");
+function defaultKxmSchemaDir() {
+  return join4(findKxmRepoRoot(import.meta.url), "schemas");
 }
-var DEFAULT_SCHEMA_DIR = defaultVnextSchemaDir();
+var DEFAULT_SCHEMA_DIR = defaultKxmSchemaDir();
 var RESOURCE_SCHEMA = Object.freeze({
   project: { identity: "kxm.project.v1", file: "project.schema.json" },
   repository: { identity: "kxm.repository.v1", file: "repository.schema.json" },
@@ -11403,7 +11403,7 @@ function sortIssues(issues) {
 // plugins/kxm/src/database.ts
 function databaseError(code, file, message) {
   const issue = { phase: "semantic", code, file, message };
-  return new VnextConfigError([issue]);
+  return new KxmConfigError([issue]);
 }
 function checkedParent(path, description) {
   const parent = dirname4(path);
@@ -13957,7 +13957,7 @@ data: ${JSON.stringify({ type: "ops", project, topic: "agents", at: nowIso() })}
         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/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "kxm-claude-plugin",
-  "version": "0.7.40",
+  "name": "claude-plugin",
+  "version": "0.7.43",
   "private": true,
   "type": "module",
   "engines": {

package/plugins/kxm/skills/kxm-project-setup/SKILL.md

@@ -12,8 +12,8 @@ invent `force`, domain-trust, or extra migrate verbs.
 
 | Command | Purpose | Options / arguments |
 |---|---|---|
-| `kxm init` | Create, validate, or plan migration of a vNext project | `--json`, `--dry-run`, `--name`, `--project-id`, `--repository <id=absolute-path>` |
-| `kxm migrate plan` | Compute the legacy-to-vNext plan without writes | `--json` |
+| `kxm init` | Create, validate, or plan migration of a KXM project | `--json`, `--dry-run`, `--name`, `--project-id`, `--repository <id=absolute-path>` |
+| `kxm migrate plan` | Compute the legacy-to-KXM plan without writes | `--json` |
 | `kxm migrate apply` | Install a reviewed migration with a hash-linked receipt | `--decisions <file>`, `--project-id`, `--name` |
 | `kxm migrate verify` | Verify a migration receipt | `--json` |
 | `kxm trust diff` | Structured permission diff against a Git revision | `--base <revision>` |

package/plugins/kxm/skills/kxm-runs/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: kxm-runs
-description: Create and inspect local vNext runs while preserving current execution-status boundaries.
+description: Create and inspect local KXM runs while preserving current execution-status boundaries.
 ---
 
 # KXM Runs
 
-`kxm run` creates a vNext run (offline-first; steps do not execute until the
+`kxm run` creates a KXM run (offline-first; steps do not execute until the
 run engine lands). Inspect with `kxm runs`. Do not invent get/create/logs
 verbs under `runs`.
 
@@ -13,7 +13,7 @@ verbs under `runs`.
 
 | Command | Purpose | Options / arguments |
 |---|---|---|
-| `kxm run [workflow] [prompt...]` | Create a vNext run (prompt is hashed, never stored raw) | `--json` |
+| `kxm run [workflow] [prompt...]` | Create a KXM run (prompt is hashed, never stored raw) | `--json` |
 | `kxm runs list` | List recent runs for the current project | `--json` |
 | `kxm runs status <runId>` | Show projected run status | `--json` |
 | `kxm runs receipt <runId>` | Print the newest drive receipt for a run | `--json`, `--all` |

package/plugins/kxm/skills/kxm-session/SKILL.md

@@ -15,7 +15,7 @@ MVP is a **local hub** on this machine. Work is agents and workflows. Do not con
 | **Hub local (MVP)** | `kxm hub bind <url>` | Bind this host to a running loopback hub; session brief + status line |
 | **SSH / HTTPS remote** | After MVP | Fail closed. Not available |
 
-In-harness Pi can attach to a local hub. Local Runtime workflow insights (`kxm dash` from the vNext event store) are after MVP.
+In-harness Pi can attach to a local hub. Local Runtime workflow insights (`kxm dash` from the KXM event store) are after MVP.
 
 ## First run (hub local)
 

package/plugins/kxm/skills/kxm-workflow/SKILL.md

@@ -17,7 +17,7 @@ in `--evidence-refs`. Caller-authored text never satisfies peer quorum.
 | `kxm workflow checkpoint [runId] [stageId] [status] [summary]` | Record a stage result | `--run-id`, `--stage-id`, `--status passed\|warning\|failed`, `--summary`, `--evidence`, `--evidence-refs` |
 | `kxm workflow record [runId] [category] [area] [summary]` | Journal plan/decision/contradiction/error/lesson | `--category`, `--area`, `--severity`, `--details`, `--evidence` |
 | `kxm workflow wait [runId] [stageId] [signalKey] [summary]` | Wait for a signed callback | `--signal-key`, `--timeout-ms`, `--evidence`, `--evidence-refs` |
-| `kxm workflow signal <runId> <signalKey> <status> <summary>` | Resume a wait or vNext run | `[evidence...]`, `--delivery-id` |
+| `kxm workflow signal <runId> <signalKey> <status> <summary>` | Resume a wait or KXM run | `[evidence...]`, `--delivery-id` |
 | `kxm workflow start [definitionId]` | POST a signed workflow-start webhook | `--payload`, `--delivery-id`, `--event` |
 | `kxm workflow export <runId>` | Export a proposed retrospective | `--input`, `--out-dir` |
 | `kxm workflow definitions` | List definitions | `--scope all\|global\|local` |

package/plugins/kxm/src/autocomplete.ts

@@ -131,15 +131,15 @@ _kxm() {
 
   local -a commands
   commands=(
-    'init:Create or validate a vNext project'
+    'init:Create or validate a KXM project'
     'migrate:Plan, apply, and verify legacy configuration migration'
     'backup:Create a verified SQLite backup manifest'
     'restore:Restore SQLite stores from a backup manifest'
-    'run:Create a vNext workflow run'
-    'runs:Inspect vNext runs'
+    'run:Create a KXM workflow run'
+    'runs:Inspect KXM runs'
     'harness:Detect coding-agent harnesses and auth'
     'update:Update kxm, harness CLIs, and model catalogs'
-    'runtime:Manage the vNext Runtime supervisor'
+    'runtime:Manage the KXM Runtime supervisor'
     'trust:Permission-diff trust review'
     'agent:Run and supervise agents'
     'session:Create manifests and brief recent hub work'

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

@@ -18,57 +18,57 @@ import { homedir } from "node:os";
 import { DatabaseSync } from "./sqlite.ts";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import {
-  VnextConfigError,
-  VnextSchemaRegistry,
+  KxmConfigError,
+  KxmSchemaRegistry,
   parseRestrictedYaml,
   type JsonObject,
-  type VnextConfigIssue,
-} from "./vnext-config.ts";
+  type KxmConfigIssue,
+} from "./project-config.ts";
 
 const MAX_BINDING_RECORD_BYTES = 256 * 1024;
 const BINDING_LABEL = "Runtime-local repository bindings";
 
-export interface VnextLocalBindingRecord {
+export interface KxmLocalBindingRecord {
   schema: "kxm.local-repository-bindings.v1";
   projectId: string;
   projectRoot: string;
   repositories: Readonly<Record<string, string>>;
 }
 
-export interface LoadedVnextLocalBindings extends VnextLocalBindingRecord {
+export interface LoadedKxmLocalBindings extends KxmLocalBindingRecord {
   file: string;
 }
 
-export interface VnextLocalBindingPathOptions {
+export interface KxmLocalBindingPathOptions {
   stateRoot?: string;
   env?: NodeJS.ProcessEnv;
   homeDir?: string;
   platform?: NodeJS.Platform;
 }
 
-export interface VnextLocalBindingStoreOptions extends VnextLocalBindingPathOptions {
+export interface KxmLocalBindingStoreOptions extends KxmLocalBindingPathOptions {
   schemasDir?: string;
 }
 
-export interface VnextLocalBindingWriteResult {
+export interface KxmLocalBindingWriteResult {
   file: string;
   written: boolean;
-  record: VnextLocalBindingRecord;
+  record: KxmLocalBindingRecord;
 }
 
-export interface VnextLocalBindingLock {
+export interface KxmLocalBindingLock {
   readonly projectRoot: string;
   readonly file: string;
 }
 
-const activeLocks = new WeakSet<VnextLocalBindingLock>();
+const activeLocks = new WeakSet<KxmLocalBindingLock>();
 
-function bindingIssue(phase: VnextConfigIssue["phase"], code: string, message: string): VnextConfigIssue {
+function bindingIssue(phase: KxmConfigIssue["phase"], code: string, message: string): KxmConfigIssue {
   return { phase, code, file: BINDING_LABEL, message };
 }
 
-function bindingError(phase: VnextConfigIssue["phase"], code: string, message: string): never {
-  throw new VnextConfigError([bindingIssue(phase, code, message)]);
+function bindingError(phase: KxmConfigIssue["phase"], code: string, message: string): never {
+  throw new KxmConfigError([bindingIssue(phase, code, message)]);
 }
 
 export function canonicalHostPath(path: string): string {
@@ -89,7 +89,7 @@ export function sameHostPath(left: string, right: string, platform = process.pla
 }
 
 /** Resolve the per-user state root without consulting any legacy KXM_* workspace override. */
-export function vnextUserStateRoot(options: VnextLocalBindingPathOptions = {}): string {
+export function kxmUserStateRoot(options: KxmLocalBindingPathOptions = {}): string {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
   const home = options.homeDir ?? homedir();
@@ -115,8 +115,8 @@ function projectBindingKey(projectRoot: string, platform = process.platform): st
   return createHash("sha256").update(keyInput, "utf8").digest("hex");
 }
 
-export function vnextLocalBindingFile(projectRoot: string, options: VnextLocalBindingPathOptions = {}): string {
-  const stateRoot = vnextUserStateRoot(options);
+export function kxmLocalBindingFile(projectRoot: string, options: KxmLocalBindingPathOptions = {}): string {
+  const stateRoot = kxmUserStateRoot(options);
   return join(stateRoot, "projects", projectBindingKey(projectRoot, options.platform), "repository-bindings.json");
 }
 
@@ -137,10 +137,10 @@ function existingBindingDirectory(file: string, stateRoot: string): boolean {
   return checkedDirectory(project, "local project binding directory");
 }
 
-function asRecord(value: JsonObject, file: string, projectRoot: string, schemasDir?: string): LoadedVnextLocalBindings {
-  const registry = new VnextSchemaRegistry(schemasDir);
+function asRecord(value: JsonObject, file: string, projectRoot: string, schemasDir?: string): LoadedKxmLocalBindings {
+  const registry = new KxmSchemaRegistry(schemasDir);
   const issues = registry.validateLocalBindings(value, BINDING_LABEL);
-  if (issues.length > 0) throw new VnextConfigError(issues);
+  if (issues.length > 0) throw new KxmConfigError(issues);
   const recordRoot = String(value.projectRoot);
   if (!sameHostPath(recordRoot, projectRoot)) {
     bindingError("semantic", "local_binding_project_root_mismatch", "binding record belongs to a different control worktree");
@@ -157,13 +157,13 @@ function asRecord(value: JsonObject, file: string, projectRoot: string, schemasD
 }
 
 /** Read one exact, bounded Runtime-local binding record. Missing state is not an error. */
-export function readVnextLocalBindings(
+export function readKxmLocalBindings(
   projectRoot: string,
-  options: VnextLocalBindingStoreOptions = {},
-): LoadedVnextLocalBindings | undefined {
+  options: KxmLocalBindingStoreOptions = {},
+): LoadedKxmLocalBindings | undefined {
   const root = resolve(projectRoot);
-  const stateRoot = vnextUserStateRoot(options);
-  const file = vnextLocalBindingFile(root, options);
+  const stateRoot = kxmUserStateRoot(options);
+  const file = kxmLocalBindingFile(root, options);
   if (!existingBindingDirectory(file, stateRoot) || !existsSync(file)) return undefined;
   const stat = lstatSync(file);
   if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -181,7 +181,7 @@ function normalizedRecord(
   projectId: string,
   repositories: Readonly<Record<string, string>>,
   schemasDir?: string,
-): VnextLocalBindingRecord {
+): KxmLocalBindingRecord {
   const normalizedRepositories = Object.fromEntries(Object.entries(repositories)
     .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
     .map(([repositoryId, path]) => {
@@ -194,12 +194,12 @@ function normalizedRecord(
     projectRoot: canonicalHostPath(projectRoot),
     repositories: normalizedRepositories,
   };
-  const issues = new VnextSchemaRegistry(schemasDir).validateLocalBindings(value, BINDING_LABEL);
-  if (issues.length > 0) throw new VnextConfigError(issues);
-  return value as unknown as VnextLocalBindingRecord;
+  const issues = new KxmSchemaRegistry(schemasDir).validateLocalBindings(value, BINDING_LABEL);
+  if (issues.length > 0) throw new KxmConfigError(issues);
+  return value as unknown as KxmLocalBindingRecord;
 }
 
-function recordsEqual(left: VnextLocalBindingRecord, right: VnextLocalBindingRecord): boolean {
+function recordsEqual(left: KxmLocalBindingRecord, right: KxmLocalBindingRecord): boolean {
   if (left.projectId !== right.projectId || !sameHostPath(left.projectRoot, right.projectRoot)) return false;
   const leftEntries = Object.entries(left.repositories);
   const rightEntries = Object.entries(right.repositories);
@@ -309,10 +309,10 @@ function projectOperationLockFile(projectRoot: string): string {
 }
 
 /** Serialize one project mutation with a process-death-released SQLite write lock. */
-export function withVnextLocalBindingLock<T>(
+export function withKxmLocalBindingLock<T>(
   projectRoot: string,
-  options: VnextLocalBindingStoreOptions,
-  callback: (lock: VnextLocalBindingLock) => T,
+  options: KxmLocalBindingStoreOptions,
+  callback: (lock: KxmLocalBindingLock) => T,
 ): T {
   const root = resolve(projectRoot);
   const file = projectOperationLockFile(root);
@@ -333,7 +333,7 @@ export function withVnextLocalBindingLock<T>(
       }
       throw error;
     }
-    const lock: VnextLocalBindingLock = Object.freeze({ projectRoot: canonicalHostPath(root), file });
+    const lock: KxmLocalBindingLock = Object.freeze({ projectRoot: canonicalHostPath(root), file });
     activeLocks.add(lock);
     try {
       return callback(lock);
@@ -346,16 +346,16 @@ export function withVnextLocalBindingLock<T>(
   }
 }
 
-export function planVnextLocalBindings(
+export function planKxmLocalBindings(
   projectRoot: string,
   projectId: string,
   repositories: Readonly<Record<string, string>>,
-  options: VnextLocalBindingStoreOptions = {},
-): VnextLocalBindingWriteResult {
+  options: KxmLocalBindingStoreOptions = {},
+): KxmLocalBindingWriteResult {
   const root = resolve(projectRoot);
-  const file = vnextLocalBindingFile(root, options);
+  const file = kxmLocalBindingFile(root, options);
   const record = normalizedRecord(root, projectId, repositories, options.schemasDir);
-  const existing = readVnextLocalBindings(root, options);
+  const existing = readKxmLocalBindings(root, options);
   if (existing?.projectId !== undefined && existing.projectId !== projectId) {
     bindingError("semantic", "local_binding_project_id_mismatch", "binding record belongs to a different project identity");
   }
@@ -363,24 +363,24 @@ export function planVnextLocalBindings(
 }
 
 /** Atomically persist validated host paths outside the Git-tracked project. */
-export function writeVnextLocalBindings(
+export function writeKxmLocalBindings(
   projectRoot: string,
   projectId: string,
   repositories: Readonly<Record<string, string>>,
-  options: VnextLocalBindingStoreOptions = {},
-  lock?: VnextLocalBindingLock,
-): VnextLocalBindingWriteResult {
+  options: KxmLocalBindingStoreOptions = {},
+  lock?: KxmLocalBindingLock,
+): KxmLocalBindingWriteResult {
   const root = resolve(projectRoot);
   if (!lock) {
-    return withVnextLocalBindingLock(root, options, (acquired) => writeVnextLocalBindings(root, projectId, repositories, options, acquired));
+    return withKxmLocalBindingLock(root, options, (acquired) => writeKxmLocalBindings(root, projectId, repositories, options, acquired));
   }
   if (!activeLocks.has(lock) || !sameHostPath(lock.projectRoot, root)) {
     bindingError("semantic", "local_binding_lock_invalid", "binding update does not hold the active project lock");
   }
-  const planned = planVnextLocalBindings(root, projectId, repositories, options);
+  const planned = planKxmLocalBindings(root, projectId, repositories, options);
   const { file, record } = planned;
   if (!planned.written) return planned;
-  ensureBindingDirectory(file, vnextUserStateRoot(options));
+  ensureBindingDirectory(file, kxmUserStateRoot(options));
   const temporary = join(dirname(file), `.repository-bindings-${process.pid}-${randomUUID()}.tmp`);
   let descriptor: number | undefined;
   try {
@@ -395,7 +395,7 @@ export function writeVnextLocalBindings(
     if (descriptor !== undefined) closeSync(descriptor);
     rmSync(temporary, { force: true });
   }
-  const verified = readVnextLocalBindings(root, options);
+  const verified = readKxmLocalBindings(root, options);
   if (!verified || !recordsEqual(verified, record)) {
     bindingError("semantic", "local_binding_install_verification_failed", "installed binding record does not match the validated input");
   }

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

@@ -22,7 +22,7 @@ import {
   classifyInstallRoot,
   type InstallProbe,
 } from "../kxm-install-kind.ts";
-import { vnextUserStateRoot } from "../vnext-bindings.ts";
+import { kxmUserStateRoot } from "../bindings.ts";
 import {
   fetchLatestKxmVersion,
   kxmReleaseAssetName,
@@ -88,7 +88,7 @@ import { homedir } from "node:os";
 export function warnIgnoredProjectUpdateYaml(runtime: Runtime): void {
   const projectFile = join(runtime.dirs.workspace, "update.yaml");
   if (!existsSync(projectFile)) return;
-  const userFile = join(vnextUserStateRoot({ env: runtime.env }), "update.yaml");
+  const userFile = join(kxmUserStateRoot({ env: runtime.env }), "update.yaml");
   runtime.io.stderr(`kxm: ignoring .kxm/update.yaml in ${runtime.dirs.workdir}; update settings are read only from ${userFile}\n`);
 }
 
@@ -162,7 +162,7 @@ export async function cmdHub(runtime: Runtime): Promise<number> {
         config = loadKxmUpdateConfig(runtime.env);
       } catch (error) {
         if (error instanceof KxmUpdateConfigError) {
-          const yamlPath = join(vnextUserStateRoot({ env: runtime.env }), "update.yaml");
+          const yamlPath = join(kxmUserStateRoot({ env: runtime.env }), "update.yaml");
           runtime.io.stderr(`kxm: ${error.message}; update check skipped; fix or remove ${yamlPath}\n`);
         } else {
           throw error;