@kontextmind/kxm 0.7.7 → 0.7.9

package/plugins/kxm/dist/runtime.js

@@ -15159,6 +15159,7 @@ function defaultSpawn(command, args, options) {
     let child;
     const finish = () => {
       if (finished) return;
+      if (stopping && !killSent) return;
       finished = true;
       for (const timer of [wallTimer, killTimer, drainTimer, reapTimer]) clearTimeout(timer);
       options.signal?.removeEventListener("abort", onAbort);
@@ -15168,7 +15169,18 @@ function defaultSpawn(command, args, options) {
       child?.unref();
       const started = Boolean(child?.pid);
       if (started && !observedChildExit) error ??= new Error("process_exit_unobserved");
-      resolve9({ 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;
+      resolve9({
+        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) => {
       killProcessTree(child, requested);
@@ -15199,7 +15211,7 @@ function defaultSpawn(command, args, 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"
       });
@@ -15243,7 +15255,7 @@ function defaultSpawn(command, args, options) {
       closed = true;
       code = exitCode;
       signal = exitSignal;
-      if (!stopping || killSent) finish();
+      finish();
     });
     options.signal?.addEventListener("abort", onAbort, { once: true });
     if (options.signal?.aborted) onAbort();
@@ -15684,6 +15696,31 @@ function defaultRunner(env) {
     }
   };
 }
+function commandResultFromSpawn(result) {
+  const errno = result.error && "code" in result.error ? result.error.code : void 0;
+  const error = (typeof errno === "string" && errno ? errno : void 0) ?? result.error?.message ?? (result.observedChildExit !== true ? "auth_probe_exit_unobserved" : void 0);
+  return {
+    ok: result.code === 0 && !error,
+    code: result.code,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    ...error ? { error } : {}
+  };
+}
+function defaultAsyncRunner(env, signal) {
+  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) {
   const line = text.split(/\r?\n/).map((candidate) => candidate.trim()).find(Boolean);
   return line && line.length <= 200 ? line : void 0;
@@ -15882,6 +15919,13 @@ function probeHarnesses(options = {}) {
     harnesses: BUILTIN_HARNESSES.map((entry) => probeEntry(entry, runCommand, timeoutMs, platform, options))
   };
 }
+async function probeHarnessesAsync(options = {}) {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnesses({ ...options, runCommand }),
+    256
+  );
+}
 function eligibleHarnesses(inventory) {
   const eligible = inventory.harnesses.filter((entry) => entry !== void 0 && entry.detected && entry.authenticated === true).map((entry) => entry.id);
   if (eligible.length === 0) throw new Error("no_authenticated_harness");
@@ -16118,35 +16162,31 @@ var PendingHarnessCommand = class {
     this.key = key;
   }
 };
-async function probeHarnessAssignmentAsync(options) {
+async function replayHarnessProbe(run, execute, limit) {
   const observed = /* @__PURE__ */ new Map();
-  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" : void 0);
-    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");
 }
+async function probeHarnessAssignmentAsync(options) {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnessAssignment({ ...options, runCommand }),
+    32
+  );
+}
 function probeHarnessesForModel(modelSpec, options = {}) {
   const timeoutMs = options.timeoutMs ?? 3e3;
   const runCommand = options.runCommand ?? defaultRunner(options.env ?? process.env);
@@ -16167,6 +16207,13 @@ function probeHarnessesForModel(modelSpec, options = {}) {
     )
   };
 }
+async function probeHarnessesForModelAsync(modelSpec, options = {}) {
+  return replayHarnessProbe(
+    options.runCommand ?? defaultAsyncRunner(options.env ?? process.env, options.signal),
+    (runCommand) => probeHarnessesForModel(modelSpec, { ...options, runCommand }),
+    256
+  );
+}
 function scopesFor(scope, entry) {
   if (scope === "self") return ["self"];
   if (scope === "extensions") return entry.update.extensions ? ["extensions"] : [];
@@ -22351,9 +22398,28 @@ import { join as join11 } from "node:path";
 import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 import { lstat, mkdir, open, rename } from "node:fs/promises";
 import { join as join6 } from "node:path";
+var ONESHOT_EVIDENCE_SCHEMA = "kxm.oneshot-evidence.v2";
+var RETIRED_ONESHOT_EVIDENCE_SCHEMAS = /* @__PURE__ */ new Set(["kxm.oneshot-evidence.v1"]);
 var TEXT_LIMIT = 4 * 1024 * 1024;
+var ARGV_LIMIT = 64 * 1024;
 var RECORD_LIMIT = 16 * 1024 * 1024;
 var digest = (value) => `sha256:${createHash7("sha256").update(value).digest("hex")}`;
+function parseOneShotEvidenceRecord(bytes) {
+  let parsed;
+  try {
+    parsed = JSON.parse(bytes);
+  } 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.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;
+}
 async function beginOneShotEvidence(root, intent, sensitive) {
   await mkdir(root, { recursive: true, mode: 448 });
   const stat = await lstat(root);
@@ -22367,11 +22433,11 @@ async function beginOneShotEvidence(root, intent, sensitive) {
   const redact = (value) => {
     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) => {
+  const bounded = (value, max = TEXT_LIMIT) => {
     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, value) => {
     const current = await lstat(dir);
@@ -22380,6 +22446,7 @@ async function beginOneShotEvidence(root, intent, sensitive) {
     }
     const bytes = JSON.stringify(value);
     if (Buffer.byteLength(bytes) > RECORD_LIMIT) throw new Error("oneshot_evidence_record_limit");
+    parseOneShotEvidenceRecord(bytes);
     const target = join6(dir, name);
     const partial = `${target}.partial`;
     const file = await open(partial, "wx", 384);
@@ -22401,7 +22468,7 @@ async function beginOneShotEvidence(root, intent, sensitive) {
     return digest(bytes);
   };
   await write("intent.json", {
-    schema: "kxm.oneshot-evidence.v1",
+    schema: ONESHOT_EVIDENCE_SCHEMA,
     id,
     recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
     runId: intent.runId,
@@ -22412,9 +22479,10 @@ async function beginOneShotEvidence(root, intent, sensitive) {
     provider: intent.provider,
     requestedModel: intent.model,
     cwd: intent.cwd,
-    command: intent.command,
-    argv: bounded(JSON.stringify(intent.args)),
+    command: redact(intent.command),
+    argv: bounded(JSON.stringify(intent.args), ARGV_LIMIT),
     stdin: intent.input === void 0 ? null : bounded(intent.input),
+    env: null,
     acceptance: false
   });
   let finished = false;
@@ -22424,7 +22492,7 @@ async function beginOneShotEvidence(root, intent, sensitive) {
       if (finished) throw new Error("oneshot_evidence_already_finished");
       finished = true;
       return write("result.json", {
-        schema: "kxm.oneshot-evidence.v1",
+        schema: ONESHOT_EVIDENCE_SCHEMA,
         id,
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
         stdout: bounded(result.stdout),
@@ -22434,6 +22502,7 @@ async function beginOneShotEvidence(root, intent, sensitive) {
         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
@@ -26106,7 +26175,8 @@ Return a final JSON object with an "outcome" field chosen from ${JSON.stringify(
       parsed = { text: "", isError: true };
     }
     const aborted = request.signal.aborted || procResult.error?.message === "process_aborted";
-    const effectUncertain = procResult.terminationRequested === true || Boolean(procResult.signal) || procResult.error?.message === "process_exit_unobserved" || procResult.observedChildExit === false && procResult.started !== false;
+    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);
     const providerMetadata = {
@@ -26118,6 +26188,7 @@ Return a final JSON object with an "outcome" field chosen from ${JSON.stringify(
     if (procResult.observedChildExit !== void 0) providerMetadata.observedChildExit = procResult.observedChildExit;
     if (procResult.started !== void 0) providerMetadata.processStarted = procResult.started;
     if (procResult.terminationRequested !== void 0) 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";
@@ -26598,7 +26669,6 @@ async function startVnextRuntimeSupervisorInner(paths, requestedPortOption, now)
               });
             } catch (err) {
               earlyError = err;
-              drivePromise = Promise.reject(err);
             }
             await Promise.resolve();
             if (earlyError) {
@@ -26624,6 +26694,7 @@ async function startVnextRuntimeSupervisorInner(paths, requestedPortOption, now)
                 } catch {
                 }
               }
+            }).catch(() => {
             });
             sendJson(response, 202, {
               ok: true,
@@ -27109,19 +27180,21 @@ function createVnextPiProducer(options = {}) {
     const parsed = parseModelString(defaultModel);
     return { provider: parsed.provider, model: parsed.model };
   }
-  function checkPiAuth(provider, model) {
+  async function checkPiAuth(provider, model, signal) {
     if (options.inventory) {
       const piEntry = options.inventory.harnesses.find((h) => h.id === "pi");
       if (!piEntry || !piEntry.detected || piEntry.authenticated === false) {
         throw new Error("pi_not_authenticated: pi harness not authenticated in inventory");
       }
     }
-    const probeFn = options.probeHarness ?? probeHarnessAssignment;
-    const probe = probeFn({
+    const probeFn = options.probeHarness ?? probeHarnessAssignmentAsync;
+    const probe = await probeFn({
       harness: "pi",
       provider,
       model,
-      env: options.env
+      env: options.env,
+      signal,
+      timeoutMs: 1e4
     });
     if (!probe.detected) {
       throw new Error(`pi_not_authenticated: pi harness not detected (${probe.issues.join(", ")})`);
@@ -27197,7 +27270,7 @@ function createVnextPiProducer(options = {}) {
     async produce(request) {
       const startTime = Date.now();
       const resolved = resolveModelForRequest(request);
-      checkPiAuth(resolved.provider, resolved.model);
+      await checkPiAuth(resolved.provider, resolved.model, request.signal);
       const session = await getOrCreateSession(request, resolved.model);
       const promptMessage = request.prompt ?? `Execute step ${request.stepId} (attempt ${request.stepAttempt}) for agent ${request.agentId}. Allowed outcomes: ${request.allowedOutcomes.join(", ")}.`;
       let promptResult;
@@ -28815,6 +28888,212 @@ function executeSshRun(params) {
     durationMs: Date.now() - startTime
   };
 }
+
+// plugins/kxm/src/subagent-control.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+var SUBAGENT_TYPES = Object.freeze([
+  "general",
+  "Explore",
+  "Plan",
+  "Reviewer",
+  "Auditor"
+]);
+var DEFAULT_SUBAGENT_MODELS = Object.freeze({
+  general: "grok/grok-4.6",
+  Explore: "openrouter/qwen/qwen3-coder-plus",
+  Plan: "claude/fable",
+  Reviewer: "openai/gpt-5.6-sol",
+  Auditor: "claude/fable"
+});
+function narrowSubagentTools(requestedTools, parentTools) {
+  if (!requestedTools || requestedTools.length === 0) {
+    return parentTools ? [...parentTools] : ["read", "grep", "find"];
+  }
+  if (!parentTools || parentTools.length === 0) {
+    return [...requestedTools];
+  }
+  const parentSet = new Set(parentTools);
+  const narrowed = [];
+  for (const tool of requestedTools) {
+    if (parentSet.has(tool)) {
+      narrowed.push(tool);
+    }
+  }
+  if (narrowed.length === 0 && requestedTools.length > 0) {
+    throw new Error(
+      `Cannot spawn subagent: requested tools [${requestedTools.join(", ")}] expand beyond parent capabilities.`
+    );
+  }
+  return narrowed;
+}
+var SubagentManager = class {
+  subagents = /* @__PURE__ */ new Map();
+  /**
+   * Spawns a new managed subagent with strict capability boundaries.
+   */
+  spawn(params) {
+    if (!params.prompt || !params.prompt.trim()) {
+      throw new Error('Subagent "prompt" is required.');
+    }
+    if (!params.description || !params.description.trim()) {
+      throw new Error('Subagent "description" is required.');
+    }
+    const type = params.type ?? "general";
+    const model = params.model ?? DEFAULT_SUBAGENT_MODELS[type] ?? "grok/grok-4.6";
+    const thinking = params.thinking ?? "low";
+    const allowedTools = narrowSubagentTools(params.allowed_tools, params.parent_tools);
+    const id = `ag_${randomUUID5().replaceAll("-", "").slice(0, 10)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record2 = {
+      id,
+      description: params.description.trim(),
+      type,
+      model,
+      thinking,
+      allowedTools,
+      status: params.background === false ? "completed" : "running",
+      turnsMax: params.turns ?? 10,
+      turnsCompleted: 0,
+      prompt: params.prompt.trim(),
+      createdAt: now,
+      updatedAt: now,
+      steeringMessages: []
+    };
+    this.subagents.set(id, record2);
+    return record2;
+  }
+  /**
+   * Dispatches an action from the `agent_control` tool.
+   */
+  control(params) {
+    const action = params.action;
+    if (action === "info") {
+      const kind = params.kind ?? "active";
+      if (kind === "types") {
+        return {
+          ok: true,
+          action: "info",
+          types: SUBAGENT_TYPES
+        };
+      }
+      if (kind === "models") {
+        return {
+          ok: true,
+          action: "info",
+          result: JSON.stringify(DEFAULT_SUBAGENT_MODELS)
+        };
+      }
+      const active = Array.from(this.subagents.values()).map((ag) => ({
+        id: ag.id,
+        description: ag.description,
+        type: ag.type,
+        status: ag.status
+      }));
+      return {
+        ok: true,
+        action: "info",
+        activeAgents: active
+      };
+    }
+    if (!params.agent_id) {
+      return {
+        ok: false,
+        action,
+        error: 'Parameter "agent_id" is required for result, steer, and stop actions.'
+      };
+    }
+    const agent = this.subagents.get(params.agent_id);
+    if (!agent) {
+      return {
+        ok: false,
+        action,
+        agent_id: params.agent_id,
+        error: `Subagent "${params.agent_id}" not found.`
+      };
+    }
+    if (action === "result") {
+      return {
+        ok: true,
+        action: "result",
+        agent_id: agent.id,
+        status: agent.status,
+        result: agent.output ?? `[Subagent is currently ${agent.status}]`
+      };
+    }
+    if (action === "steer") {
+      if (!params.message || !params.message.trim()) {
+        return {
+          ok: false,
+          action: "steer",
+          agent_id: agent.id,
+          error: 'Parameter "message" is required for steer action.'
+        };
+      }
+      if (agent.status === "completed" || agent.status === "stopped" || agent.status === "failed") {
+        return {
+          ok: false,
+          action: "steer",
+          agent_id: agent.id,
+          error: `Cannot steer subagent "${agent.id}" because it is already ${agent.status}.`
+        };
+      }
+      agent.steeringMessages.push({
+        text: params.message.trim(),
+        injectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        processed: false
+      });
+      agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        ok: true,
+        action: "steer",
+        agent_id: agent.id,
+        status: agent.status,
+        steered: true
+      };
+    }
+    if (action === "stop") {
+      agent.status = "stopped";
+      agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        ok: true,
+        action: "stop",
+        agent_id: agent.id,
+        status: "stopped",
+        stopped: true
+      };
+    }
+    return {
+      ok: false,
+      action,
+      error: `Unknown control action "${action}".`
+    };
+  }
+  /**
+   * Retrieves an agent record by ID.
+   */
+  get(agentId) {
+    return this.subagents.get(agentId);
+  }
+  /**
+   * Marks a subagent as completed with output.
+   */
+  complete(agentId, output) {
+    const agent = this.subagents.get(agentId);
+    if (agent) {
+      agent.status = "completed";
+      agent.output = output;
+      agent.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  /**
+   * Returns all active running subagents.
+   */
+  listActive() {
+    return Array.from(this.subagents.values()).filter(
+      (ag) => ag.status === "running" || ag.status === "pending" || ag.status === "blocked"
+    );
+  }
+};
 export {
   BUILTIN_HARNESSES,
   BUILTIN_HARNESS_IDS,
@@ -28825,6 +29104,7 @@ export {
   DEFAULT_LOG_MAX_FILES,
   DEFAULT_MODES_CONFIG,
   DEFAULT_SOCKET_DIR,
+  DEFAULT_SUBAGENT_MODELS,
   IMPROVEMENT_REPORT_SCHEMA,
   IMPROVEMENT_REPORT_V1_SCHEMA,
   LOG_LEVEL_PRIORITY,
@@ -28835,7 +29115,9 @@ export {
   PI_NATIVE_BRAKE_PROVIDERS,
   PiSession,
   SAFE_HARNESS_COMMAND_ID,
+  SUBAGENT_TYPES,
   SteelClient,
+  SubagentManager,
   VIEWPORT_PRESETS,
   VNEXT_ABSENT_MEMORY_REVISION,
   VNEXT_EVENT_STORE_SCHEMA_VERSION,
@@ -28898,6 +29180,7 @@ export {
   isVnextRuntimeContextClosed,
   isWindowsHarnessShim,
   loadModesConfig,
+  narrowSubagentTools,
   newVnextAssignmentId,
   newVnextAttemptId,
   newVnextCommandId,
@@ -28921,7 +29204,9 @@ export {
   probeHarnessAssignment,
   probeHarnessAssignmentAsync,
   probeHarnesses,
+  probeHarnessesAsync,
   probeHarnessesForModel,
+  probeHarnessesForModelAsync,
   projectRuntimeKey,
   pruneSocketDir,
   readVnextRunStatus,