@kontextmind/kxm 0.7.7 → 0.7.9

package/plugins/kxm/src/vnext-harness.ts

@@ -58,14 +58,22 @@ export interface HarnessCatalogEntry {
   oneShot?: HarnessOneShotConfig | undefined;
 }
 
+export type HarnessRunCommand = (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult;
+export type HarnessRunCommandAsync = (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult | Promise<HarnessCommandResult>;
+
 export interface HarnessProbeOptions {
   env?: NodeJS.ProcessEnv | undefined;
-  runCommand?: ((command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult) | undefined;
+  runCommand?: HarnessRunCommand | undefined;
   timeoutMs?: number | undefined;
   platform?: NodeJS.Platform | undefined;
   existsSync?: ((path: string) => boolean) | undefined;
 }
 
+export interface AsyncHarnessProbeOptions extends Omit<HarnessProbeOptions, "runCommand"> {
+  signal?: AbortSignal | undefined;
+  runCommand?: HarnessRunCommandAsync | undefined;
+}
+
 export interface HarnessDispatchStatus {
   status: "yes" | "no";
   supported: boolean;
@@ -598,7 +606,7 @@ export function findWinNpmInnerExe(
   return undefined;
 }
 
-function defaultRunner(env: NodeJS.ProcessEnv): (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult {
+function defaultRunner(env: NodeJS.ProcessEnv): HarnessRunCommand {
   return (command, args, timeoutMs) => {
     try {
       const result = spawnSync(command, [...args], {
@@ -624,6 +632,37 @@ function defaultRunner(env: NodeJS.ProcessEnv): (command: string, args: readonly
   };
 }
 
+function commandResultFromSpawn(result: Awaited<ReturnType<typeof defaultSpawn>>): HarnessCommandResult {
+  const errno = result.error && "code" in result.error
+    ? (result.error as NodeJS.ErrnoException).code
+    : undefined;
+  const error = (typeof errno === "string" && errno ? errno : undefined)
+    ?? result.error?.message
+    ?? (result.observedChildExit !== true ? "auth_probe_exit_unobserved" : undefined);
+  return {
+    ok: result.code === 0 && !error,
+    code: result.code,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    ...(error ? { error } : {}),
+  };
+}
+
+function defaultAsyncRunner(env: NodeJS.ProcessEnv, signal?: AbortSignal): HarnessRunCommandAsync {
+  return async (command, args, timeoutMs) => {
+    try {
+      return commandResultFromSpawn(await defaultSpawn(command, args, {
+        env,
+        timeoutMs,
+        signal,
+        shell: harnessSpawnUsesShell(command),
+      }));
+    } catch (error) {
+      return { ok: false, code: null, stdout: "", stderr: "", error: error instanceof Error ? error.message : "spawn_failed" };
+    }
+  };
+}
+
 function firstLine(text: string): string | undefined {
   const line = text.split(/\r?\n/).map((candidate) => candidate.trim()).find(Boolean);
   return line && line.length <= 200 ? line : undefined;
@@ -858,6 +897,18 @@ export function probeHarnesses(options: HarnessProbeOptions = {}): HarnessInvent
   };
 }
 
+/**
+ * Inventory probe that never uses spawnSync. Product CLI/hub/extension paths
+ * must await this so capability/auth checks cannot block the event loop.
+ */
+export async function probeHarnessesAsync(options: AsyncHarnessProbeOptions = {}): Promise<HarnessInventory> {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnesses({ ...options, runCommand }),
+    256,
+  );
+}
+
 export function eligibleHarnesses(inventory: HarnessInventory): readonly string[] {
   const eligible = inventory.harnesses
     .filter((entry) => entry !== undefined && entry.detected && entry.authenticated === true)
@@ -1118,7 +1169,7 @@ export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions):
 
 export interface AsyncHarnessAssignmentProbeOptions extends Omit<HarnessAssignmentProbeOptions, "runCommand"> {
   signal?: AbortSignal | undefined;
-  runCommand?: ((command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult | Promise<HarnessCommandResult>) | undefined;
+  runCommand?: HarnessRunCommandAsync | undefined;
 }
 
 class PendingHarnessCommand {
@@ -1134,37 +1185,43 @@ class PendingHarnessCommand {
   }
 }
 
-/**
- * Execute the existing probe policy without blocking the Runtime event loop.
- * Replay pure policy decisions from per-call command observations, yielding for
- * every missing observation. This reuses the exact auth/model/brake parsers,
- * deduplicates repeated detection, and never caches auth across assignments.
- */
-export async function probeHarnessAssignmentAsync(options: AsyncHarnessAssignmentProbeOptions): Promise<HarnessStatus> {
+async function replayHarnessProbe<T>(
+  run: HarnessRunCommandAsync,
+  execute: (runCommand: HarnessRunCommand) => T,
+  limit: number,
+): Promise<T> {
   const observed = new Map<string, HarnessCommandResult>();
-  const run = options.runCommand ?? (async (command, args, timeoutMs) => {
-    const result = await defaultSpawn(command, args, { env: options.env, timeoutMs, signal: options.signal });
-    const error = result.error?.message ?? (result.observedChildExit !== true ? "auth_probe_exit_unobserved" : undefined);
-    return { ok: result.code === 0 && !error, code: result.code, stdout: result.stdout, stderr: result.stderr,
-      ...(error ? { error } : {}) };
-  });
-  for (let commands = 0; commands <= 32; commands++) {
+  for (let commands = 0; commands <= limit; commands++) {
     try {
-      return probeHarnessAssignment({ ...options, runCommand(command, args, timeoutMs) {
+      return execute((command, args, timeoutMs) => {
         const key = JSON.stringify([command, args, timeoutMs]);
         const result = observed.get(key);
         if (result) return result;
         throw new PendingHarnessCommand(command, args, timeoutMs, key);
-      } });
+      });
     } catch (pending) {
       if (!(pending instanceof PendingHarnessCommand)) throw pending;
-      if (commands === 32) throw new Error("auth_probe_command_limit");
+      if (commands === limit) throw new Error("auth_probe_command_limit");
       observed.set(pending.key, await run(pending.command, pending.args, pending.timeoutMs));
     }
   }
   throw new Error("auth_probe_command_limit");
 }
 
+/**
+ * Execute the existing probe policy without blocking the Runtime event loop.
+ * Replay pure policy decisions from per-call command observations, yielding for
+ * every missing observation. This reuses the exact auth/model/brake parsers,
+ * deduplicates repeated detection, and never caches auth across assignments.
+ */
+export async function probeHarnessAssignmentAsync(options: AsyncHarnessAssignmentProbeOptions): Promise<HarnessStatus> {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnessAssignment({ ...options, runCommand }),
+    32,
+  );
+}
+
 export function probeHarnessesForModel(
   modelSpec: HarnessModelSpec,
   options: HarnessProbeOptions = {},
@@ -1189,6 +1246,17 @@ export function probeHarnessesForModel(
   };
 }
 
+export async function probeHarnessesForModelAsync(
+  modelSpec: HarnessModelSpec,
+  options: AsyncHarnessProbeOptions = {},
+): Promise<HarnessInventory> {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnessesForModel(modelSpec, { ...options, runCommand }),
+    256,
+  );
+}
+
 function scopesFor(scope: HarnessUpdateScope, entry: HarnessCatalogEntry): Exclude<HarnessUpdateScope, "all">[] {
   if (scope === "self") return ["self"];
   if (scope === "extensions") return entry.update.extensions ? ["extensions"] : [];

package/plugins/kxm/src/vnext-oneshot-evidence.ts

@@ -3,10 +3,37 @@ import { lstat, mkdir, open, rename } from "node:fs/promises";
 import { join } from "node:path";
 import type { VnextOneShotProcessResult } from "./vnext-oneshot-process.ts";
 
+export const ONESHOT_EVIDENCE_SCHEMA = "kxm.oneshot-evidence.v2" as const;
+const RETIRED_ONESHOT_EVIDENCE_SCHEMAS = new Set(["kxm.oneshot-evidence.v1"]);
+
 const TEXT_LIMIT = 4 * 1024 * 1024;
+const ARGV_LIMIT = 64 * 1024;
 const RECORD_LIMIT = 16 * 1024 * 1024;
 const digest = (value: string): string => `sha256:${createHash("sha256").update(value).digest("hex")}`;
 
+export interface OneShotEvidenceRecord {
+  schema: typeof ONESHOT_EVIDENCE_SCHEMA;
+  [key: string]: unknown;
+}
+
+/** Brake: retired and unknown persisted schema ids are never aliased or upgraded. */
+export function parseOneShotEvidenceRecord(bytes: string): OneShotEvidenceRecord {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(bytes) as unknown;
+  } catch {
+    throw new Error("oneshot_evidence_record_invalid");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("oneshot_evidence_record_invalid");
+  }
+  const schema = (parsed as { schema?: unknown }).schema;
+  if (typeof schema !== "string") throw new Error("oneshot_evidence_record_invalid");
+  if (RETIRED_ONESHOT_EVIDENCE_SCHEMAS.has(schema)) throw new Error("oneshot_evidence_schema_retired");
+  if (schema !== ONESHOT_EVIDENCE_SCHEMA) throw new Error("oneshot_evidence_schema_unknown");
+  return parsed as OneShotEvidenceRecord;
+}
+
 /** Private diagnostic evidence, never a peer reply or acceptance authority.
  * Retained until operator archival; no automatic deletion of failed attempts.
  * Each record is bounded; inability to reserve/write evidence fails closed.
@@ -32,11 +59,13 @@ export async function beginOneShotEvidence(root: string, intent: {
   const redact = (value: string): string => {
     let text = value;
     for (const secret of secrets) text = text.replaceAll(secret, "[REDACTED]");
-    return text.replace(/(\b(?:authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|password|secret)\b["']?\s*[:=]\s*["']?)(?:Bearer\s+)?[^\s"',;}]+/gi, "$1[REDACTED]");
+    return text
+      .replace(/(\b(?:authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|password|secret)\b["']?\s*[:=]\s*["']?)(?:Bearer\s+)?[^\s"',;}]+/gi, "$1[REDACTED]")
+      .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]");
   };
-  const bounded = (value: string): { text: string; truncated: boolean; sha256: string } => {
+  const bounded = (value: string, max = TEXT_LIMIT): { text: string; truncated: boolean; sha256: string } => {
     const bytes = Buffer.from(redact(value));
-    return { text: bytes.subarray(0, TEXT_LIMIT).toString("utf8"), truncated: bytes.length > TEXT_LIMIT, sha256: digest(value) };
+    return { text: bytes.subarray(0, max).toString("utf8"), truncated: bytes.length > max, sha256: digest(redact(value)) };
   };
   const write = async (name: string, value: unknown): Promise<string> => {
     const current = await lstat(dir);
@@ -46,6 +75,7 @@ export async function beginOneShotEvidence(root: string, intent: {
     }
     const bytes = JSON.stringify(value);
     if (Buffer.byteLength(bytes) > RECORD_LIMIT) throw new Error("oneshot_evidence_record_limit");
+    parseOneShotEvidenceRecord(bytes);
     const target = join(dir, name);
     const partial = `${target}.partial`;
     const file = await open(partial, "wx", 0o600);
@@ -59,11 +89,12 @@ export async function beginOneShotEvidence(root: string, intent: {
     return digest(bytes);
   };
   await write("intent.json", {
-    schema: "kxm.oneshot-evidence.v1", id, recordedAt: new Date().toISOString(),
+    schema: ONESHOT_EVIDENCE_SCHEMA, id, recordedAt: new Date().toISOString(),
     runId: intent.runId, stepId: intent.stepId, attemptId: intent.attemptId, assignmentId: intent.assignmentId,
     harness: intent.harness, provider: intent.provider, requestedModel: intent.model,
-    cwd: intent.cwd, command: intent.command,
-    argv: bounded(JSON.stringify(intent.args)), stdin: intent.input === undefined ? null : bounded(intent.input),
+    cwd: intent.cwd, command: redact(intent.command),
+    argv: bounded(JSON.stringify(intent.args), ARGV_LIMIT), stdin: intent.input === undefined ? null : bounded(intent.input),
+    env: null,
     acceptance: false,
   });
   let finished = false;
@@ -73,10 +104,11 @@ export async function beginOneShotEvidence(root: string, intent: {
       if (finished) throw new Error("oneshot_evidence_already_finished");
       finished = true;
       return write("result.json", {
-        schema: "kxm.oneshot-evidence.v1", id, recordedAt: new Date().toISOString(),
+        schema: ONESHOT_EVIDENCE_SCHEMA, id, recordedAt: new Date().toISOString(),
         stdout: bounded(result.stdout), stderr: bounded(result.stderr),
         code: result.code, signal: result.signal ?? null, started: result.started ?? null,
         observedChildExit: result.observedChildExit ?? null, terminationRequested: result.terminationRequested ?? null,
+        unverifiedDescendants: result.unverifiedDescendants ?? null,
         error: result.error ? bounded(result.error.message) : null,
         observation: bounded(JSON.stringify(observation)), acceptance: false,
       });

package/plugins/kxm/src/vnext-oneshot-process.ts

@@ -9,6 +9,11 @@ export interface VnextOneShotProcessResult {
   started?: boolean | undefined;
   /** Stop was requested; direct-child reaping cannot attest escaped descendants. */
   terminationRequested?: boolean | undefined;
+  /**
+   * Direct-child close/reap is not descendant death. Unobserved process-group
+   * members stay unverified: never success, never a forged descendant failure.
+   */
+  unverifiedDescendants?: boolean | undefined;
   error?: Error | undefined;
 }
 
@@ -18,6 +23,8 @@ export interface VnextOneShotSpawnOptions {
   input?: string | undefined;
   timeoutMs?: number | undefined;
   signal?: AbortSignal | undefined;
+  /** Only allowlisted Windows `.cmd` probes may set this; never a user string. */
+  shell?: boolean | undefined;
 }
 export type VnextOneShotSpawn = (command: string, args: readonly string[], options: VnextOneShotSpawnOptions) => Promise<VnextOneShotProcessResult>;
 
@@ -71,6 +78,9 @@ export function defaultSpawn(command: string, args: readonly string[], options:
     let child: ReturnType<typeof spawn>;
     const finish = (): void => {
       if (finished) return;
+      // Direct-child close must not cancel SIGTERM → SIGKILL. Refuse to settle
+      // until the group kill has been sent, then reap on the existing timers.
+      if (stopping && !killSent) return;
       finished = true;
       for (const timer of [wallTimer, killTimer, drainTimer, reapTimer]) clearTimeout(timer);
       options.signal?.removeEventListener("abort", onAbort);
@@ -80,7 +90,18 @@ export function defaultSpawn(command: string, args: readonly string[], options:
       child?.unref();
       const started = Boolean(child?.pid);
       if (started && !observedChildExit) error ??= new Error("process_exit_unobserved");
-      resolve({ stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), code, signal, started, observedChildExit, terminationRequested: stopping, ...(error ? { error } : {}) });
+      const unverifiedDescendants = stopping || (started && !observedChildExit);
+      resolve({
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+        code,
+        signal,
+        started,
+        observedChildExit,
+        terminationRequested: stopping,
+        ...(unverifiedDescendants ? { unverifiedDescendants: true } : {}),
+        ...(error ? { error } : {}),
+      });
     };
     const kill = (requested: NodeJS.Signals): void => {
       killProcessTree(child, requested);
@@ -108,7 +129,7 @@ export function defaultSpawn(command: string, args: readonly string[], options:
         cwd: options.cwd,
         env: options.env ?? process.env,
         stdio: ["pipe", "pipe", "pipe"],
-        shell: false,
+        shell: options.shell === true,
         windowsHide: true,
         detached: process.platform !== "win32",
       });
@@ -153,8 +174,8 @@ export function defaultSpawn(command: string, args: readonly string[], options:
       code = exitCode;
       signal = exitSignal;
       // The leader can exit and close its pipes while a descendant ignores TERM.
-      // Never cancel the pending group escalation just because close arrived.
-      if (!stopping || killSent) finish();
+      // finish() no-ops until SIGKILL when escalation is in flight.
+      finish();
     });
     options.signal?.addEventListener("abort", onAbort, { once: true });
     if (options.signal?.aborted) onAbort();

package/plugins/kxm/src/vnext-oneshot-producer.ts

@@ -252,9 +252,11 @@ export function createVnextOneShotProducer(options: VnextOneShotProducerOptions
       const aborted = request.signal.aborted || procResult.error?.message === "process_aborted";
       // Process groups are cleanup, not containment. A detached descendant or
       // provider leader may outlive the client; interrupted effects need recovery.
-      const effectUncertain = procResult.terminationRequested === true || Boolean(procResult.signal)
+      const unverifiedDescendants = procResult.unverifiedDescendants === true
+        || procResult.terminationRequested === true
         || procResult.error?.message === "process_exit_unobserved"
         || (procResult.observedChildExit === false && procResult.started !== false);
+      const effectUncertain = unverifiedDescendants || Boolean(procResult.signal);
       const transportFailed = procResult.code !== 0 || Boolean(procResult.error) || effectUncertain;
       const outcome = aborted ? "cancelled" : transportFailed || parsed.isError ? "failed"
         : determineOutcome(parsed.text, request.allowedOutcomes);
@@ -267,6 +269,7 @@ export function createVnextOneShotProducer(options: VnextOneShotProducerOptions
       if (procResult.observedChildExit !== undefined) providerMetadata.observedChildExit = procResult.observedChildExit;
       if (procResult.started !== undefined) providerMetadata.processStarted = procResult.started;
       if (procResult.terminationRequested !== undefined) providerMetadata.terminationRequested = procResult.terminationRequested;
+      if (unverifiedDescendants) providerMetadata.descendantEffects = "unverified";
       if (procResult.error) {
         const reason = procResult.error.message;
         providerMetadata.processError = /^process_(aborted|timeout|output_limit|stdin_error|stdio_error|stdio_unclosed|exit_unobserved)$/.test(reason) ? reason : "process_error";

package/plugins/kxm/src/vnext-pi-producer.ts

@@ -8,8 +8,10 @@ import {
   type VnextProducerResult,
 } from "./vnext-engine.ts";
 import {
-  probeHarnessAssignment,
+  probeHarnessAssignmentAsync,
+  type HarnessAssignmentProbeOptions,
   type HarnessInventory,
+  type HarnessStatus,
 } from "./vnext-harness.ts";
 import {
   calculateModelCost,
@@ -386,7 +388,7 @@ export interface VnextPiProducerOptions {
   priceCatalog?: PriceCatalog | undefined;
   env?: NodeJS.ProcessEnv | undefined;
   spawnProcess?: ((command: string, args: readonly string[], options: Record<string, unknown>) => PiRpcProcess) | undefined;
-  probeHarness?: typeof probeHarnessAssignment | undefined;
+  probeHarness?: ((options: Omit<HarnessAssignmentProbeOptions, "runCommand"> & { signal?: AbortSignal | undefined }) => HarnessStatus | Promise<HarnessStatus>) | undefined;
   resolveModel?: ((agentId: string, runId: string) => { provider?: string | undefined; model?: string | undefined; thinking?: string | undefined } | undefined) | undefined;
   defaultModel?: string | undefined;
   defaultProvider?: string | undefined;
@@ -438,7 +440,7 @@ export function createVnextPiProducer(options: VnextPiProducerOptions = {}): Vne
     return { provider: parsed.provider, model: parsed.model };
   }
 
-  function checkPiAuth(provider: string, model: string): void {
+  async function checkPiAuth(provider: string, model: string, signal: AbortSignal): Promise<void> {
     if (options.inventory) {
       const piEntry = options.inventory.harnesses.find((h) => h.id === "pi");
       if (!piEntry || !piEntry.detected || piEntry.authenticated === false) {
@@ -446,12 +448,14 @@ export function createVnextPiProducer(options: VnextPiProducerOptions = {}): Vne
       }
     }
 
-    const probeFn = options.probeHarness ?? probeHarnessAssignment;
-    const probe = probeFn({
+    const probeFn = options.probeHarness ?? probeHarnessAssignmentAsync;
+    const probe = await probeFn({
       harness: "pi",
       provider,
       model,
       env: options.env,
+      signal,
+      timeoutMs: 10_000,
     });
 
     if (!probe.detected) {
@@ -538,8 +542,8 @@ export function createVnextPiProducer(options: VnextPiProducerOptions = {}): Vne
       const startTime = Date.now();
       const resolved = resolveModelForRequest(request);
 
-      // Preflight auth check - fails closed
-      checkPiAuth(resolved.provider, resolved.model);
+      // Preflight auth check - fails closed via the async bounded probe
+      await checkPiAuth(resolved.provider, resolved.model, request.signal);
 
       // Get or create session
       const session = await getOrCreateSession(request, resolved.model);

package/plugins/kxm/src/vnext-runtime-supervisor.ts

@@ -476,7 +476,7 @@ async function startVnextRuntimeSupervisorInner(
                   });
                 })();
 
-            let drivePromise: Promise<unknown>;
+            let drivePromise: Promise<unknown> | undefined;
             let earlyError: unknown;
             try {
               const scheduler = VnextRunScheduler.for(context, bundle);
@@ -484,7 +484,6 @@ async function startVnextRuntimeSupervisorInner(
               drivePromise.catch((err) => { earlyError = err; });
             } catch (err) {
               earlyError = err;
-              drivePromise = Promise.reject(err);
             }
 
             // Yield microtask to catch synchronous duplicate queue check (e.g. run_busy)
@@ -503,11 +502,14 @@ async function startVnextRuntimeSupervisorInner(
               throw earlyError;
             }
 
-            void drivePromise.finally(async () => {
+            void drivePromise!.finally(async () => {
               cleanupActive();
               if ("close" in producer && typeof producer.close === "function") {
                 try { await producer.close(); } catch { /* ignore */ }
               }
+            }).catch(() => {
+              // Derived finally() re-rejects when the admitted drive or cleanup
+              // throws; void does not consume that. Keep the request 202.
             });
 
             sendJson(response, 202, {