@kontextmind/kxm 0.7.40 → 0.7.43

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

@@ -4,40 +4,40 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync,
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { dirname, isAbsolute, join } from "node:path";
 import { findKxmRepoRoot } from "./repo-root.ts";
-import { loadVnextProject, VnextConfigError, type VnextConfigOptions } from "./vnext-config.ts";
+import { loadKxmProject, KxmConfigError, type KxmConfigOptions } from "./project-config.ts";
 import {
-  VnextRuntimeRegistry,
+  KxmRuntimeRegistry,
   projectRuntimeKey,
   runtimeError,
-  verifyVnextDriveReceipt,
-  vnextRuntimePaths,
-  type VnextRuntimePaths,
-} from "./vnext-runtime-store.ts";
+  verifyKxmDriveReceipt,
+  kxmRuntimePaths,
+  type KxmRuntimePaths,
+} from "./runtime-store.ts";
 import {
-  acceptVnextRun,
-  cancelVnextRun,
-  closeVnextRuntimeContext,
-  foldStoredVnextRun,
-  openVnextRuntimeContext,
-  projectVnextRunReadOnly,
-  type VnextRuntimeContext,
-} from "./vnext-runtime.ts";
-import { createVnextOneShotProducer } from "./vnext-oneshot-producer.ts";
+  acceptKxmRun,
+  cancelKxmRun,
+  closeKxmRuntimeContext,
+  foldStoredKxmRun,
+  openKxmRuntimeContext,
+  projectKxmRunReadOnly,
+  type KxmRuntimeContext,
+} from "./runtime-service.ts";
+import { createKxmOneShotProducer } from "./oneshot-producer.ts";
 import { isRouteAdmitted } from "./routes.ts";
-import { VnextRunScheduler, createVnextSimulatedProducer, recordDriveReceipt, recoverVnextRun, vnextDrivePollProjection } from "./vnext-engine.ts";
-import { vnextDriveSession, vnextOpenDriveSessions } from "./vnext-runtime-owner.ts";
+import { KxmRunScheduler, createKxmSimulatedProducer, recordDriveReceipt, recoverKxmRun, kxmDrivePollProjection } from "./engine.ts";
+import { kxmDriveSession, kxmOpenDriveSessions } from "./runtime-owner.ts";
 
 /* ------------------------------------------------------------------ *
  * Token management
  * ------------------------------------------------------------------ */
 
-export function vnextSupervisorTokenFile(paths: VnextRuntimePaths): string {
+export function kxmSupervisorTokenFile(paths: KxmRuntimePaths): string {
   return join(paths.runtimeDir, "supervisor.token");
 }
 
 /** Atomically publish the supervisor token (temp file + rename). */
-function publishVnextSupervisorToken(paths: VnextRuntimePaths, token: string): void {
-  const file = vnextSupervisorTokenFile(paths);
+function publishKxmSupervisorToken(paths: KxmRuntimePaths, token: string): void {
+  const file = kxmSupervisorTokenFile(paths);
   mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
   const temp = `${file}.${process.pid}.tmp`;
   writeFileSync(temp, `${token}\n`, { encoding: "utf8", mode: 0o600 });
@@ -46,12 +46,12 @@ function publishVnextSupervisorToken(paths: VnextRuntimePaths, token: string): v
   try { chmodSync(file, 0o600); } catch { /* Windows may ignore modes */ }
 }
 
-export function hashVnextSupervisorToken(token: string): string {
+export function hashKxmSupervisorToken(token: string): string {
   return `sha256:${createHash("sha256").update(`kxm-runtime-supervisor\0${token}`, "utf8").digest("hex")}`;
 }
 
-export function readVnextSupervisorToken(paths: VnextRuntimePaths): string | undefined {
-  const file = vnextSupervisorTokenFile(paths);
+export function readKxmSupervisorToken(paths: KxmRuntimePaths): string | undefined {
+  const file = kxmSupervisorTokenFile(paths);
   const stat = lstatSync(file, { throwIfNoEntry: false });
   if (!stat) return undefined;
   if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -65,7 +65,7 @@ export function readVnextSupervisorToken(paths: VnextRuntimePaths): string | und
  * Supervisor process state + liveness
  * ------------------------------------------------------------------ */
 
-export interface VnextSupervisorStatus {
+export interface KxmSupervisorStatus {
   running: boolean;
   runtimeId?: string;
   pid?: number;
@@ -87,23 +87,23 @@ function processAlive(pid: number): boolean {
 const HEARTBEAT_STALE_MS = 15_000;
 const SUPERVISOR_ERROR_MAX_AGE_MS = 30_000;
 
-function supervisorErrorFile(paths: VnextRuntimePaths): string {
+function supervisorErrorFile(paths: KxmRuntimePaths): string {
   return join(paths.runtimeDir, "supervisor.error");
 }
 
-function clearSupervisorError(paths: VnextRuntimePaths): void {
+function clearSupervisorError(paths: KxmRuntimePaths): void {
   const file = supervisorErrorFile(paths);
   if (existsSync(file)) rmSync(file, { force: true });
 }
 
-function recordSupervisorError(paths: VnextRuntimePaths, message: string): void {
+function recordSupervisorError(paths: KxmRuntimePaths, message: string): void {
   try {
     mkdirSync(paths.runtimeDir, { recursive: true, mode: 0o700 });
     writeFileSync(supervisorErrorFile(paths), `${message}\n`, { encoding: "utf8", mode: 0o600 });
   } catch { /* best effort */ }
 }
 
-function readRecentSupervisorError(paths: VnextRuntimePaths): string | undefined {
+function readRecentSupervisorError(paths: KxmRuntimePaths): string | undefined {
   const file = supervisorErrorFile(paths);
   const stat = lstatSync(file, { throwIfNoEntry: false });
   if (!stat) return undefined;
@@ -116,9 +116,9 @@ function readRecentSupervisorError(paths: VnextRuntimePaths): string | undefined
   }
 }
 
-export function vnextSupervisorStatus(paths: VnextRuntimePaths): VnextSupervisorStatus {
+export function kxmSupervisorStatus(paths: KxmRuntimePaths): KxmSupervisorStatus {
   if (!existsSync(paths.registryDb)) return { running: false };
-  const registry = new VnextRuntimeRegistry(paths.registryDb);
+  const registry = new KxmRuntimeRegistry(paths.registryDb);
   try {
     const record = registry.supervisor();
     if (!record) return { running: false };
@@ -159,7 +159,7 @@ async function probeSupervisor(port: number, expectedRuntimeId: string, token: s
     const payload = await response.json() as { runtimeId?: string; tokenProof?: string };
     // The server must prove it knows the current token: an impostor that
     // merely binds the stale port cannot answer the keyed challenge.
-    const expectedProof = hashVnextTokenProof(token, nonce);
+    const expectedProof = hashKxmTokenProof(token, nonce);
     return payload.runtimeId === expectedRuntimeId && payload.tokenProof === expectedProof;
   } catch {
     return false;
@@ -168,11 +168,11 @@ async function probeSupervisor(port: number, expectedRuntimeId: string, token: s
   }
 }
 
-export function hashVnextTokenProof(token: string, nonce: string): string {
+export function hashKxmTokenProof(token: string, nonce: string): string {
   return createHmac("sha256", token).update(`kxm-runtime-token-proof\0${nonce}`, "utf8").digest("hex");
 }
 
-export interface VnextSupervisorHandle {
+export interface KxmSupervisorHandle {
   runtimeId: string;
   port: number;
   token: string;
@@ -180,14 +180,14 @@ export interface VnextSupervisorHandle {
 }
 
 /** Ensure a supervisor is running: reuse a live one, otherwise auto-start. */
-export async function ensureVnextSupervisor(
+export async function ensureKxmSupervisor(
   options: { stateRoot?: string; env?: NodeJS.ProcessEnv; spawnImpl?: (scriptPath: string, env: NodeJS.ProcessEnv) => number } = {},
-): Promise<VnextSupervisorHandle> {
-  const paths = vnextRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : { ...(options.env ? { env: options.env } : {}) });
-  const status = vnextSupervisorStatus(paths);
+): Promise<KxmSupervisorHandle> {
+  const paths = kxmRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : { ...(options.env ? { env: options.env } : {}) });
+  const status = kxmSupervisorStatus(paths);
   if (status.running && status.port) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
-      const token = readVnextSupervisorToken(paths);
+      const token = readKxmSupervisorToken(paths);
       if (token && (await probeSupervisorWithRetry(status.port, status.runtimeId as string, token))) {
         return { runtimeId: status.runtimeId as string, port: status.port, token, started: false };
       }
@@ -221,9 +221,9 @@ export async function ensureVnextSupervisor(
   const deadline = Date.now() + 10_000;
   while (Date.now() < deadline) {
     await new Promise((resolveWait) => setTimeout(resolveWait, 100));
-    const next = vnextSupervisorStatus(paths);
+    const next = kxmSupervisorStatus(paths);
     if (next.running && next.port) {
-      const token = readVnextSupervisorToken(paths);
+      const token = readKxmSupervisorToken(paths);
       if (token && (await probeSupervisor(next.port, next.runtimeId as string, token))) {
         // Entry status had no live supervisor: this call caused a start
         // (ours or a concurrent winner's), which the probe just confirmed.
@@ -270,7 +270,7 @@ async function readJsonBody(request: IncomingMessage, limit = 64 * 1024): Promis
     }
     return parsed as JsonBody;
   } catch (error) {
-    if (error instanceof VnextConfigError) throw error;
+    if (error instanceof KxmConfigError) throw error;
     throw runtimeError("runtime_request_invalid", request.url ?? "<request>", "request body is not valid JSON");
   }
 }
@@ -329,58 +329,58 @@ async function driveSessionStillPending(settled: Promise<unknown>): Promise<bool
   return pending;
 }
 
-export interface VnextRuntimeSupervisor {
+export interface KxmRuntimeSupervisor {
   server: Server;
   port: number;
   runtimeId: string;
   stop: () => Promise<void>;
 }
 
-export async function startVnextRuntimeSupervisor(
+export async function startKxmRuntimeSupervisor(
   options: { stateRoot?: string; port?: number; now?: () => string } = {},
-): Promise<VnextRuntimeSupervisor> {
+): Promise<KxmRuntimeSupervisor> {
   const now = options.now ?? (() => new Date().toISOString());
-  const paths = vnextRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : {});
+  const paths = kxmRuntimePaths(options.stateRoot !== undefined ? { stateRoot: options.stateRoot } : {});
   try {
-    return await startVnextRuntimeSupervisorInner(paths, options.port, now);
+    return await startKxmRuntimeSupervisorInner(paths, options.port, now);
   } catch (error) {
     // Startup failures are recorded so auto-start clients see the real cause
     // instead of a bare timeout. Conflict is not an error: the winner is
     // probed and reused instead.
-    if (!(error instanceof VnextConfigError && error.issues.some((issue) => issue.code === "runtime_supervisor_conflict"))) {
+    if (!(error instanceof KxmConfigError && error.issues.some((issue) => issue.code === "runtime_supervisor_conflict"))) {
       recordSupervisorError(paths, (error as Error).message);
     }
     throw error;
   }
 }
 
-async function startVnextRuntimeSupervisorInner(
-  paths: VnextRuntimePaths,
+async function startKxmRuntimeSupervisorInner(
+  paths: KxmRuntimePaths,
   requestedPortOption: number | undefined,
   now: () => string,
-): Promise<VnextRuntimeSupervisor> {
+): Promise<KxmRuntimeSupervisor> {
   mkdirSync(paths.runtimeDir, { recursive: true, mode: 0o700 });
   mkdirSync(paths.projectsDir, { recursive: true, mode: 0o700 });
   // The token is generated in memory and written only after the supervisor
   // singleton is owned: a losing supervisor can never overwrite a winner's
   // token and lock every client out.
   const token = randomBytes(32).toString("hex");
-  const tokenHash = hashVnextSupervisorToken(token);
-  const registry = new VnextRuntimeRegistry(paths.registryDb);
+  const tokenHash = hashKxmSupervisorToken(token);
+  const registry = new KxmRuntimeRegistry(paths.registryDb);
 
   const runtimeId = `rtm_${createHash("sha256").update(`${paths.stateRoot}\0${process.pid}\0${now()}\0${randomBytes(16).toString("hex")}`, "utf8").digest("hex").slice(0, 24)}`;
   const requestedPort = requestedPortOption ?? 0;
   let activeRuntimeId = runtimeId;
 
-  const contexts = new Map<string, VnextRuntimeContext>();
-  const contextFor = (projectRoot: string): VnextRuntimeContext => {
+  const contexts = new Map<string, KxmRuntimeContext>();
+  const contextFor = (projectRoot: string): KxmRuntimeContext => {
     if (!isAbsolute(projectRoot)) {
       throw runtimeError("runtime_request_invalid", "projectRoot", "projectRoot must be an absolute path");
     }
     const key = projectRuntimeKey(projectRoot);
     const existing = contexts.get(key);
     if (existing) return existing;
-    const context = openVnextRuntimeContext(projectRoot, { homeRuntimeId: activeRuntimeId, stateRoot: paths.stateRoot });
+    const context = openKxmRuntimeContext(projectRoot, { homeRuntimeId: activeRuntimeId, stateRoot: paths.stateRoot });
     contexts.set(key, context);
     return context;
   };
@@ -388,7 +388,7 @@ async function startVnextRuntimeSupervisorInner(
   const requireAuth = (request: IncomingMessage): void => {
     const header = request.headers.authorization ?? "";
     const presented = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
-    const presentedHash = presented.length > 0 ? Buffer.from(hashVnextSupervisorToken(presented), "utf8") : Buffer.alloc(0);
+    const presentedHash = presented.length > 0 ? Buffer.from(hashKxmSupervisorToken(presented), "utf8") : Buffer.alloc(0);
     const expectedHash = Buffer.from(tokenHash, "utf8");
     if (presentedHash.length !== expectedHash.length || !timingSafeEqual(presentedHash, expectedHash)) {
       throw runtimeError("runtime_auth_failed", request.url ?? "<request>", "missing or invalid supervisor token");
@@ -407,7 +407,7 @@ async function startVnextRuntimeSupervisorInner(
             state: "running",
             // Proof of token knowledge: an impostor that merely binds the
             // stale port cannot answer the keyed challenge.
-            tokenProof: nonce.length > 0 ? hashVnextTokenProof(token, nonce) : undefined,
+            tokenProof: nonce.length > 0 ? hashKxmTokenProof(token, nonce) : undefined,
           });
           return;
         }
@@ -429,8 +429,8 @@ async function startVnextRuntimeSupervisorInner(
             return;
           }
           const context = contextFor(projectRoot);
-          const bundle = loadVnextProject(projectRoot, {});
-          const acceptance = acceptVnextRun(context, bundle, {
+          const bundle = loadKxmProject(projectRoot, {});
+          const acceptance = acceptKxmRun(context, bundle, {
             ...(typeof body.commandId === "string" && body.commandId.length > 0 ? { commandId: body.commandId } : {}),
             workflowId,
             prompt,
@@ -454,11 +454,11 @@ async function startVnextRuntimeSupervisorInner(
             return;
           }
           const context = contextFor(projectRoot);
-          const bundle = loadVnextProject(projectRoot, {});
+          const bundle = loadKxmProject(projectRoot, {});
           if (request.method === "GET" && !sub) {
-            const projected = projectVnextRunReadOnly(context, runId);
-            const folded = foldStoredVnextRun(context, projected);
-            const drive = vnextDrivePollProjection(context, runId, folded);
+            const projected = projectKxmRunReadOnly(context, runId);
+            const folded = foldStoredKxmRun(context, projected);
+            const drive = kxmDrivePollProjection(context, runId, folded);
             sendJson(response, 200, { ok: true, run: projected, ...(drive !== undefined ? { drive } : {}) });
             return;
           }
@@ -473,7 +473,7 @@ async function startVnextRuntimeSupervisorInner(
 
             const delayMs = typeof body.delayMs === "number" && body.delayMs > 0 ? body.delayMs : 0;
             const createProducer = () => body.mode === "live"
-              ? createVnextOneShotProducer({
+              ? createKxmOneShotProducer({
                   projectRoot,
                   defaultHarness: String(bundle.project.value.defaultHarness ?? "pi"),
                   resolveHarness: (agentId) => {
@@ -493,17 +493,17 @@ async function startVnextRuntimeSupervisorInner(
                     return { provider, model: modelName };
                   },
                 })
-              : createVnextSimulatedProducer(async () => {
+              : createKxmSimulatedProducer(async () => {
                   if (delayMs > 0) {
                     await new Promise((r) => setTimeout(r, delayMs));
                   }
                   return { outcome: "passed" };
                 });
 
-            let session: Awaited<ReturnType<VnextRunScheduler["openDriveSession"]>> | undefined;
+            let session: Awaited<ReturnType<KxmRunScheduler["openDriveSession"]>> | undefined;
             let earlyError: unknown;
             try {
-              const scheduler = VnextRunScheduler.for(context, bundle);
+              const scheduler = KxmRunScheduler.for(context, bundle);
               const opening = scheduler.openDriveSession(runId, {
                 mode: body.mode,
                 allowLimits: false,
@@ -557,7 +557,7 @@ async function startVnextRuntimeSupervisorInner(
             const run = context.eventStore.run(runId);
             if (!run) throw runtimeError("run_unknown", runId, "run not found");
 
-            const activeSession = vnextDriveSession(context.eventStore.path, runId);
+            const activeSession = kxmDriveSession(context.eventStore.path, runId);
             const session = activeSession
               ? {
                   driveId: activeSession.driveId,
@@ -572,7 +572,7 @@ async function startVnextRuntimeSupervisorInner(
           }
           if (request.method === "POST" && sub === "cancel") {
             const body = await readJsonBody(request);
-            const result = cancelVnextRun(context, runId, {
+            const result = cancelKxmRun(context, runId, {
               ...(typeof body.commandId === "string" && body.commandId.length > 0 ? { commandId: body.commandId } : {}),
             });
             sendJson(response, 200, { ok: true, idempotent: result.idempotent, run: result.run, events: result.events });
@@ -582,11 +582,11 @@ async function startVnextRuntimeSupervisorInner(
             const body = await readJsonBody(request);
             const run = context.eventStore.run(runId);
             if (!run) throw runtimeError("run_unknown", runId, "run not found");
-            const state = foldStoredVnextRun(context, run);
+            const state = foldStoredKxmRun(context, run);
             let unblocked = false;
             if (state.status === "blocked_uncertain" || state.status === "cancelling" || state.currentStep?.effectState === "blocked_uncertain") {
               const action = body.action === "cancel" || body.action === "fail" || body.action === "retry" || body.action === "unblock" ? body.action : "unblock";
-              const rec = recoverVnextRun(context, runId, {
+              const rec = recoverKxmRun(context, runId, {
                 action,
                 reason: typeof body.summary === "string" ? body.summary : `signal_${body.signalKey ?? "callback"}`,
               });
@@ -633,9 +633,9 @@ async function startVnextRuntimeSupervisorInner(
             sendJson(response, 200, { ok: true, receipt, verified: false, divergence: "run missing" });
             return;
           }
-          const state = foldStoredVnextRun(context, stored);
+          const state = foldStoredKxmRun(context, stored);
           const events = context.eventStore.events(runId, 0, 1_000_000);
-          const checked = verifyVnextDriveReceipt(receipt, events, state.status, { runId, driveId });
+          const checked = verifyKxmDriveReceipt(receipt, events, state.status, { runId, driveId });
           sendJson(response, 200, {
             ok: true,
             receipt,
@@ -665,7 +665,7 @@ async function startVnextRuntimeSupervisorInner(
 
         sendJson(response, 404, { ok: false, error: "runtime_not_found" });
       } catch (error) {
-        if (error instanceof VnextConfigError) {
+        if (error instanceof KxmConfigError) {
           const code = error.issues[0]?.code ?? "runtime_error";
           const status = code === "runtime_auth_failed" ? 401 : code === "run_unknown" ? 404 : 400;
           sendJson(response, status, { ok: false, error: code, issues: error.issues });
@@ -714,7 +714,7 @@ async function startVnextRuntimeSupervisorInner(
   // Ownership is established: publish the token atomically so concurrent
   // readers never see a truncated file, and clear any stale startup error.
   try {
-    publishVnextSupervisorToken(paths, token);
+    publishKxmSupervisorToken(paths, token);
     clearSupervisorError(paths);
   } catch (error) {
     registry.close();
@@ -741,11 +741,11 @@ async function startVnextRuntimeSupervisorInner(
     clearInterval(heartbeat);
     try { registry.markStopping(process.pid, now()); } catch { /* best effort */ }
     const openSessions = [...contexts.values()].flatMap((context) => (
-      vnextOpenDriveSessions(context.eventStore.path).map((session) => ({ context, session }))
+      kxmOpenDriveSessions(context.eventStore.path).map((session) => ({ context, session }))
     ));
     for (const { context, session } of openSessions) {
       try {
-        cancelVnextRun(context, session.runId, { reason: "runtime_shutdown" });
+        cancelKxmRun(context, session.runId, { reason: "runtime_shutdown" });
       } catch {
         // Terminal or already cancelling runs still release on session settle.
       }
@@ -765,7 +765,7 @@ async function startVnextRuntimeSupervisorInner(
         producerClosed: false,
       });
     }
-    for (const context of contexts.values()) closeVnextRuntimeContext(context);
+    for (const context of contexts.values()) closeKxmRuntimeContext(context);
     contexts.clear();
     const closed = new Promise<void>((resolveStop) => server.close(() => resolveStop()));
     server.closeIdleConnections?.();
@@ -784,8 +784,8 @@ async function startVnextRuntimeSupervisorInner(
  * Thin client used by the CLI
  * ------------------------------------------------------------------ */
 
-export async function vnextRuntimeRequest(
-  handle: VnextSupervisorHandle,
+export async function kxmRuntimeRequest(
+  handle: KxmSupervisorHandle,
   method: "GET" | "POST",
   path: string,
   body?: unknown,

package/plugins/kxm/src/runtime.ts

@@ -1,9 +1,9 @@
-export * from "./vnext-runtime.ts";
-export * from "./vnext-runtime-store.ts";
-export * from "./vnext-runtime-supervisor.ts";
-export * from "./vnext-pi-producer.ts";
-export * from "./vnext-oneshot-producer.ts";
-export * from "./vnext-harness.ts";
+export * from "./runtime-service.ts";
+export * from "./runtime-store.ts";
+export * from "./runtime-supervisor.ts";
+export * from "./pi-producer.ts";
+export * from "./oneshot-producer.ts";
+export * from "./harness.ts";
 export * from "./database.ts";
 export * from "./logger.ts";
 export * from "./improve.ts";

package/plugins/kxm/src/session-work.ts

@@ -53,7 +53,7 @@ export interface SessionBrief {
   schema: "kxm.session-brief.v1";
   generatedAt: string;
   staleSeconds: number;
-  source: "legacy" | "vnext" | "both";
+  source: "legacy" | "runtime" | "both";
   hub: SessionHubStatus;
   stats: SessionWorkStats;
   tasks: SessionWorkItem[];
@@ -257,14 +257,14 @@ export function formatSessionWidget(
 }
 
 export function buildSessionBrief(
-  snapshot: Pick<LocalMeshSnapshot, "runs" | "plans" | "openMessageTotal" | "runTotal"> & { source?: "legacy" | "vnext" | "both" | undefined },
+  snapshot: Pick<LocalMeshSnapshot, "runs" | "plans" | "openMessageTotal" | "runTotal"> & { source?: "legacy" | "runtime" | "both" | undefined },
   current?: SessionWorkItem,
   hub?: SessionHubStatus,
   ship?: SessionShipStatus,
   updateLatest?: string,
   cost?: string,
   sessionToken?: string,
-  source?: "legacy" | "vnext" | "both" | undefined,
+  source?: "legacy" | "runtime" | "both" | undefined,
   staleSeconds = DEFAULT_SESSION_BRIEF_STALE_SECONDS,
 ): SessionBrief {
   const resolvedSource = source ?? snapshot.source ?? "legacy";

package/plugins/kxm/src/studio-layout.ts

@@ -6,8 +6,8 @@
 
 import { createServer, type IncomingMessage, type ServerResponse, type Server } from "node:http";
 import { randomUUID } from "node:crypto";
-import type { VnextCompiledPlan, VnextCompiledStep } from "./vnext-engine-compile.ts";
-import type { VnextRunState } from "./vnext-engine-fold.ts";
+import type { KxmCompiledPlan, KxmCompiledStep } from "./engine-compile.ts";
+import type { KxmRunState } from "./engine-fold.ts";
 
 export const STUDIO_LAYOUT_SCHEMA = "kxm.studio-layout.v1" as const;
 
@@ -76,8 +76,8 @@ export interface StudioLayoutPayload {
  * without requiring any manual layout coordinates in the YAML workflow file.
  */
 export function generateStudioLayout(
-  plan: VnextCompiledPlan,
-  state?: VnextRunState | undefined,
+  plan: KxmCompiledPlan,
+  state?: KxmRunState | undefined,
 ): StudioLayoutPayload {
   const generatedAt = new Date().toISOString();
   const stepIds = Object.keys(plan.steps);
@@ -287,8 +287,8 @@ export interface StudioServerOptions {
   host?: string | undefined;
   projectRoot?: string | undefined;
   sessionToken?: string | undefined;
-  planProvider?: (() => VnextCompiledPlan | undefined) | undefined;
-  stateProvider?: (() => VnextRunState | undefined) | undefined;
+  planProvider?: (() => KxmCompiledPlan | undefined) | undefined;
+  stateProvider?: (() => KxmRunState | undefined) | undefined;
   onMutation?: ((command: string, args: Record<string, unknown>) => Promise<{ ok: boolean; result?: unknown; error?: string }> | { ok: boolean; result?: unknown; error?: string }) | undefined;
 }
 

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

@@ -1,37 +1,37 @@
 import { createHash } from "node:crypto";
 import { stringify } from "yaml";
-import type { JsonObject, JsonValue } from "./vnext-config.ts";
+import type { JsonObject, JsonValue } from "./project-config.ts";
 
-export const VNEXT_TEMPLATE_ID = "builtin-minimal";
-export const VNEXT_TEMPLATE_PROVENANCE_PATH = ".kxm/template-provenance.yaml";
-export const CURRENT_VNEXT_TEMPLATE_VARIANT: VnextTemplateVariant = "v4-registry";
-export const SUPPORTED_VNEXT_TEMPLATE_VARIANTS = ["v1", "v2", "v3-policy", "v4-registry"] as const;
+export const KXM_TEMPLATE_ID = "builtin-minimal";
+export const KXM_TEMPLATE_PROVENANCE_PATH = ".kxm/template-provenance.yaml";
+export const CURRENT_KXM_TEMPLATE_VARIANT: KxmTemplateVariant = "v4-registry";
+export const SUPPORTED_KXM_TEMPLATE_VARIANTS = ["v1", "v2", "v3-policy", "v4-registry"] as const;
 
-export type VnextTemplateVariant = typeof SUPPORTED_VNEXT_TEMPLATE_VARIANTS[number];
+export type KxmTemplateVariant = typeof SUPPORTED_KXM_TEMPLATE_VARIANTS[number];
 
-export interface VnextTemplateFileRecord {
+export interface KxmTemplateFileRecord {
   path: string;
   sha256: string;
   authoritySha256: string;
   bytes: number;
 }
 
-export interface VnextTemplateProvenance {
+export interface KxmTemplateProvenance {
   schema: "kxm.template-provenance.v1";
-  templateId: typeof VNEXT_TEMPLATE_ID;
+  templateId: typeof KXM_TEMPLATE_ID;
   templateRevision: string;
   inputs: {
     projectId: string;
     projectName: string;
   };
-  files: readonly VnextTemplateFileRecord[];
+  files: readonly KxmTemplateFileRecord[];
 }
 
-export interface VnextRenderedTemplate {
+export interface KxmRenderedTemplate {
   projectId: string;
   projectName: string;
   templateRevision: string;
-  provenance: VnextTemplateProvenance;
+  provenance: KxmTemplateProvenance;
   files: ReadonlyMap<string, Buffer>;
   values: ReadonlyMap<string, JsonObject>;
 }
@@ -49,7 +49,7 @@ function canonicalJson(value: JsonValue): string {
     .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key] as JsonValue)}`).join(",")}}`;
 }
 
-export function vnextContentSha256(input: string | Uint8Array): string {
+export function kxmContentSha256(input: string | Uint8Array): string {
   return `sha256:${createHash("sha256").update(input).digest("hex")}`;
 }
 
@@ -62,11 +62,11 @@ function authorityProjection(value: JsonObject): JsonObject {
   return projected;
 }
 
-export function vnextAuthoritySha256(value: JsonObject): string {
-  return vnextContentSha256(canonicalJson(authorityProjection(value)));
+export function kxmAuthoritySha256(value: JsonObject): string {
+  return kxmContentSha256(canonicalJson(authorityProjection(value)));
 }
 
-function coreTemplate(projectId: string, projectName: string, variant: VnextTemplateVariant): ReadonlyMap<string, JsonObject> {
+function coreTemplate(projectId: string, projectName: string, variant: KxmTemplateVariant): ReadonlyMap<string, JsonObject> {
   const files = new Map<string, JsonObject>([
     [".kxm/project.yaml", {
       schema: "kxm.project.v1",
@@ -182,8 +182,8 @@ function coreTemplate(projectId: string, projectName: string, variant: VnextTemp
   return files;
 }
 
-function provenanceRevision(files: readonly VnextTemplateFileRecord[]): string {
-  return vnextContentSha256(canonicalJson(files.map((file) => ({
+function provenanceRevision(files: readonly KxmTemplateFileRecord[]): string {
+  return kxmContentSha256(canonicalJson(files.map((file) => ({
     path: file.path,
     sha256: file.sha256,
     authoritySha256: file.authoritySha256,
@@ -191,11 +191,11 @@ function provenanceRevision(files: readonly VnextTemplateFileRecord[]): string {
   }))));
 }
 
-export function renderVnextTemplate(
+export function renderKxmTemplate(
   projectId: string,
   projectName: string,
-  variant: VnextTemplateVariant = CURRENT_VNEXT_TEMPLATE_VARIANT,
-): VnextRenderedTemplate {
+  variant: KxmTemplateVariant = CURRENT_KXM_TEMPLATE_VARIANT,
+): KxmRenderedTemplate {
   const values = coreTemplate(projectId, projectName, variant);
   const coreFiles = new Map<string, Buffer>();
   const records = [...values.entries()].map(([path, value]) => {
@@ -203,22 +203,22 @@ export function renderVnextTemplate(
     coreFiles.set(path, bytes);
     return {
       path,
-      sha256: vnextContentSha256(bytes),
-      authoritySha256: vnextAuthoritySha256(value),
+      sha256: kxmContentSha256(bytes),
+      authoritySha256: kxmAuthoritySha256(value),
       bytes: bytes.byteLength,
-    } satisfies VnextTemplateFileRecord;
+    } satisfies KxmTemplateFileRecord;
   }).sort((left, right) => compareCodeUnits(left.path, right.path));
   const templateRevision = provenanceRevision(records);
-  const provenance: VnextTemplateProvenance = {
+  const provenance: KxmTemplateProvenance = {
     schema: "kxm.template-provenance.v1",
-    templateId: VNEXT_TEMPLATE_ID,
+    templateId: KXM_TEMPLATE_ID,
     templateRevision,
     inputs: { projectId, projectName },
     files: records,
   };
   const fileEntries: [string, Buffer][] = [...coreFiles.entries()];
   fileEntries.push([
-    VNEXT_TEMPLATE_PROVENANCE_PATH,
+    KXM_TEMPLATE_PROVENANCE_PATH,
     Buffer.from(stringify(provenance as unknown as JsonObject, { lineWidth: 0 }), "utf8"),
   ]);
   fileEntries.sort(([left], [right]) => compareCodeUnits(left, right));
@@ -226,18 +226,18 @@ export function renderVnextTemplate(
   return { projectId, projectName, templateRevision, provenance, files, values };
 }
 
-export function validatedTemplateProvenance(value: JsonObject): VnextTemplateProvenance | undefined {
-  if (value.schema !== "kxm.template-provenance.v1" || value.templateId !== VNEXT_TEMPLATE_ID) return undefined;
-  const candidate = value as unknown as VnextTemplateProvenance;
+export function validatedTemplateProvenance(value: JsonObject): KxmTemplateProvenance | undefined {
+  if (value.schema !== "kxm.template-provenance.v1" || value.templateId !== KXM_TEMPLATE_ID) return undefined;
+  const candidate = value as unknown as KxmTemplateProvenance;
   return provenanceRevision(candidate.files) === candidate.templateRevision ? candidate : undefined;
 }
 
 /** Resolve provenance only when its complete manifest equals a built-in baseline. */
-export function resolveVnextTemplateBaseline(value: JsonObject): VnextTemplateProvenance | undefined {
+export function resolveKxmTemplateBaseline(value: JsonObject): KxmTemplateProvenance | undefined {
   const candidate = validatedTemplateProvenance(value);
   if (!candidate) return undefined;
-  for (const variant of SUPPORTED_VNEXT_TEMPLATE_VARIANTS) {
-    const known = renderVnextTemplate(candidate.inputs.projectId, candidate.inputs.projectName, variant).provenance;
+  for (const variant of SUPPORTED_KXM_TEMPLATE_VARIANTS) {
+    const known = renderKxmTemplate(candidate.inputs.projectId, candidate.inputs.projectName, variant).provenance;
     if (known.templateRevision === candidate.templateRevision
       && canonicalJson(known as unknown as JsonObject) === canonicalJson(candidate as unknown as JsonObject)) {
       return candidate;