@kontextmind/kxm 0.7.0 → 0.7.10

package/plugins/kxm/dist/runtime.js

@@ -2986,7 +2986,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve8.call(this, root, ref);
+      let _sch = resolve9.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3013,7 +3013,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve8(root, ref) {
+    function resolve9(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3834,11 +3834,11 @@ var require_fast_uri = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse5(serialize(uri, options), options);
+        parse6(serialize(uri, options), options);
       }
       return uri;
     }
-    function resolve8(baseURI, relativeURI, options) {
+    function resolve9(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -3874,8 +3874,8 @@ var require_fast_uri = __commonJS({
     function resolveComponent(base, relative5, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse5(serialize(base, options), options);
-        relative5 = parse5(serialize(relative5, options), options);
+        base = parse6(serialize(base, options), options);
+        relative5 = parse6(serialize(relative5, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative5.scheme) {
@@ -4167,7 +4167,7 @@ var require_fast_uri = __commonJS({
       }
       return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
-    function parse5(uri, opts) {
+    function parse6(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
     }
     function normalizeString(uri, opts) {
@@ -4200,11 +4200,11 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve8,
+      resolve: resolve9,
       resolveComponent,
       equal,
       serialize,
-      parse: parse5
+      parse: parse6
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -14674,7 +14674,7 @@ var require_public_api = __commonJS({
       }
       return doc;
     }
-    function parse5(src, reviver, options) {
+    function parse6(src, reviver, options) {
       let _reviver = void 0;
       if (typeof reviver === "function") {
         _reviver = reviver;
@@ -14715,7 +14715,7 @@ var require_public_api = __commonJS({
         return value.toString(options);
       return new Document.Document(value, _replacer, options).toString(options);
     }
-    exports.parse = parse5;
+    exports.parse = parse6;
     exports.parseAllDocuments = parseAllDocuments;
     exports.parseDocument = parseDocument2;
     exports.stringify = stringify3;
@@ -15122,11 +15122,24 @@ var OUTPUT_LIMIT = 8 * 1024 * 1024;
 var KILL_GRACE_MS = 250;
 var DRAIN_GRACE_MS = 500;
 var REAP_GRACE_MS = 1e3;
+function killProcessTree(child, signal = "SIGKILL") {
+  if (process.platform !== "win32" && child.pid) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
 function defaultSpawn(command, args, options) {
   if (options.signal?.aborted) {
     return Promise.resolve({ stdout: "", stderr: "", code: null, started: false, observedChildExit: false, error: new Error("process_aborted") });
   }
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const stdout = [];
     const stderr = [];
     let outputBytes = 0;
@@ -15146,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);
@@ -15155,14 +15169,21 @@ function defaultSpawn(command, args, options) {
       child?.unref();
       const started = Boolean(child?.pid);
       if (started && !observedChildExit) error ??= new Error("process_exit_unobserved");
-      resolve8({ 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) => {
-      try {
-        if (process.platform !== "win32" && child.pid) process.kill(-child.pid, requested);
-        else child.kill(requested);
-      } catch {
-      }
+      killProcessTree(child, requested);
     };
     const stop = (reason) => {
       if (finished) return;
@@ -15190,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"
       });
@@ -15234,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();
@@ -15489,7 +15510,9 @@ function parseAgyOneShotUsage(stdout, _stderr) {
 var READ_ONLY_ONESHOT_ARGS = Object.freeze({
   claude: Object.freeze(["--tools", "Read,Glob,Grep", "--restricted", "--safe-mode", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}', "--disable-slash-commands", "--no-session-persistence"]),
   codex: Object.freeze(["--sandbox", "read-only", "--ignore-user-config", "-c", 'approval_policy="never"']),
-  grok: Object.freeze(["--sandbox", "read-only", "--permission-mode", "plan", "--tools", "Read,Glob,Grep", "--no-subagents", "--disable-web-search"])
+  grok: Object.freeze(["--sandbox", "read-only", "--permission-mode", "plan", "--tools", "Read,Glob,Grep", "--no-subagents", "--disable-web-search"]),
+  agy: Object.freeze(["--mode", "plan", "--sandbox", "--disable-slash-commands"]),
+  kimi: Object.freeze(["--plan"])
 });
 function oneShotReadOnlyArgs(harness) {
   return Object.hasOwn(READ_ONLY_ONESHOT_ARGS, harness) ? READ_ONLY_ONESHOT_ARGS[harness] : void 0;
@@ -15543,7 +15566,7 @@ var BUILTIN_HARNESSES = Object.freeze([
     authArgs: ["provider", "list"],
     update: { self: ["upgrade"] },
     oneShot: {
-      argv: ["--output-format", "stream-json", "-p"],
+      argv: [...oneShotReadOnlyArgs("kimi"), "--output-format", "stream-json", "-p"],
       promptVia: "arg",
       outputFormat: "stream-json",
       usageParser: parseKimiOneShotUsage
@@ -15606,7 +15629,7 @@ var BUILTIN_HARNESSES = Object.freeze([
     authArgs: ["models"],
     update: { self: ["update"] },
     oneShot: {
-      argv: ["--output-format", "json", "-p"],
+      argv: [...oneShotReadOnlyArgs("agy"), "--output-format", "json", "-p"],
       promptVia: "arg",
       outputFormat: "json",
       usageParser: parseAgyOneShotUsage
@@ -15673,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;
@@ -15871,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");
@@ -16107,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);
@@ -16156,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"] : [];
@@ -16914,8 +16972,8 @@ function validateWorkflow(workflow, agents, models, repositories, gates, issues)
       const writable = Object.values(objectValue(step.repositories) ?? {}).filter((access) => access === "write").length;
       if (maxWriteRepositories > writable) issues.push(issue2("semantic", "write_repository_bound_invalid", file, `${stepId} maxWriteRepositories exceeds writable repository scope`));
     }
-    const join15 = objectValue(step.join);
-    const minimumPassed = join15 && typeof join15.minimumPassed === "number" ? join15.minimumPassed : void 0;
+    const join17 = objectValue(step.join);
+    const minimumPassed = join17 && typeof join17.minimumPassed === "number" ? join17.minimumPassed : void 0;
     if (minimumPassed !== void 0 && minimumPassed > maximum) issues.push(issue2("semantic", "join_impossible", file, `${stepId} minimumPassed exceeds assignment maximum`));
     const distinctBy = names(assignment?.distinctBy);
     if (distinctBy.length > 0) {
@@ -17060,7 +17118,7 @@ function validateModelReferences(models, issues) {
   };
   for (const id of models.keys()) walk(id, []);
 }
-function validateBundle(project, repositories, agents, models, workflows, environments, options, gateRegistry) {
+function validateBundle(project, repositories, agents, models, workflows, environments, options, gateRegistry, projectRoot) {
   const issues = [];
   const entries = valuesOf(project.value, "repositories").map((candidate) => objectValue(candidate)).filter((candidate) => Boolean(candidate));
   const repositoryIds = /* @__PURE__ */ new Set();
@@ -17128,6 +17186,33 @@ function validateBundle(project, repositories, agents, models, workflows, enviro
   const defaultWorkflow = stringValue(project.value.defaultWorkflow) ?? "default";
   if (!workflows.has(defaultWorkflow)) issues.push(issue2("reference", "default_workflow_unknown", project.logicalPath, `default workflow ${defaultWorkflow} does not exist`));
   for (const workflow of workflows.values()) validateWorkflow(workflow, agents, models, repositoryIds, gates, issues);
+  if (projectRoot) {
+    const writerRolePath = join(projectRoot, ".kxm", "roles", "writer.yaml");
+    const implementerAgent = agents.get("implementer") ?? agents.get("writer");
+    if (existsSync2(writerRolePath) && implementerAgent) {
+      try {
+        const rawRole = parseRestrictedYaml2(readFileSync(writerRolePath, "utf8"));
+        const roleObj = objectValue(rawRole);
+        const rosterEntries = valuesOf(roleObj ?? {}, "roster").map((candidate) => objectValue(candidate)).filter((entry) => Boolean(entry));
+        const enabledRosterModels = rosterEntries.filter((entry) => entry.enabled !== false).map((entry) => stringValue(entry.model)).filter((m) => Boolean(m));
+        const agentModelObj = objectValue(implementerAgent.value.model);
+        const agentModelStr = stringValue(implementerAgent.value.model);
+        const agentProvider = agentModelObj ? stringValue(agentModelObj.provider) : void 0;
+        const agentModel = agentModelObj ? stringValue(agentModelObj.model) : agentModelStr;
+        const canonicalAgentModel = agentProvider && agentModel ? `${agentProvider}/${agentModel}` : agentModel;
+        if (enabledRosterModels.length > 0 && canonicalAgentModel) {
+          const matches = enabledRosterModels.some((rm) => rm === canonicalAgentModel || rm === agentModel || rm.endsWith(`/${agentModel}`));
+          if (!matches) {
+            issues.push(issue2("semantic", "role_roster_conflicts_with_agent", ".kxm/roles/writer.yaml", `role roster in .kxm/roles/writer.yaml does not include agent model ${canonicalAgentModel} from ${implementerAgent.logicalPath}`));
+          }
+        }
+      } catch (error) {
+        if (error instanceof VnextConfigError) {
+          issues.push(...error.issues);
+        }
+      }
+    }
+  }
   return sortIssues2(issues);
 }
 function vnextCanonicalJson(value) {
@@ -17308,7 +17393,7 @@ function loadVnextProject(projectRoot, options = {}) {
     }
   }
   if (loadIssues.length > 0) throw new VnextConfigError(loadIssues);
-  const issues = validateBundle(project, repositories, agents, models, workflows, environments, options, gateRegistry);
+  const issues = validateBundle(project, repositories, agents, models, workflows, environments, options, gateRegistry, root);
   if (issues.length > 0) throw new VnextConfigError(issues);
   const resources = [project, ...repositories.values(), ...agents.values(), ...models.values(), ...workflows.values(), ...environments, ...gateRegistry ? [gateRegistry] : []].sort((left, right) => compareCodeUnits3(left.logicalPath, right.logicalPath));
   return {
@@ -17420,7 +17505,47 @@ import { dirname as dirname4, join as join4, resolve as resolve4 } from "node:pa
 
 // plugins/kxm/src/vnext-bindings.ts
 import { homedir } from "node:os";
-import { DatabaseSync } from "node:sqlite";
+
+// plugins/kxm/src/sqlite.ts
+import { createRequire } from "node:module";
+var requireFromHere = createRequire(import.meta.url);
+function loadNative() {
+  try {
+    const mod = requireFromHere("node:sqlite");
+    if (mod.DatabaseSync) return { Ctor: mod.DatabaseSync, bun: false };
+  } catch {
+  }
+  try {
+    const mod = requireFromHere("bun:sqlite");
+    const Ctor = mod?.DatabaseSync ?? mod?.Database;
+    if (Ctor) return { Ctor, bun: true };
+  } catch {
+  }
+  throw new Error("kxm: no supported sqlite module found (need node:sqlite or bun:sqlite)");
+}
+var native = loadNative();
+var DatabaseSync = class {
+  inner;
+  constructor(path, options) {
+    let normalized = options;
+    if (native.bun && options) {
+      const { readOnly, ...rest } = options;
+      normalized = readOnly === void 0 ? rest : { ...rest, readonly: readOnly };
+    }
+    this.inner = normalized === void 0 ? new native.Ctor(path) : new native.Ctor(path, normalized);
+  }
+  prepare(sql) {
+    return this.inner.prepare(sql);
+  }
+  exec(sql) {
+    return this.inner.exec(sql);
+  }
+  close() {
+    this.inner.close();
+  }
+};
+
+// plugins/kxm/src/vnext-bindings.ts
 import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, parse, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 var MAX_BINDING_RECORD_BYTES = 256 * 1024;
 var BINDING_LABEL = "Runtime-local repository bindings";
@@ -17464,7 +17589,6 @@ import {
   writeFileSync
 } from "node:fs";
 import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function databaseError(code, file, message) {
   const issue3 = { phase: "semantic", code, file, message };
   return new VnextConfigError([issue3]);
@@ -17544,7 +17668,7 @@ function openDatabase(file, description, spec) {
       }
     }
   }
-  const database = new DatabaseSync2(file);
+  const database = new DatabaseSync(file);
   let transaction = false;
   try {
     database.exec(`PRAGMA busy_timeout = ${spec.timeoutMs ?? 5e3}`);
@@ -17648,7 +17772,7 @@ function backupDatabaseFile(sourcePath, targetPath, storeId) {
   if (existsSync3(resolvedTarget)) {
     unlinkSync(resolvedTarget);
   }
-  const sourceDb = new DatabaseSync2(resolvedSource);
+  const sourceDb = new DatabaseSync(resolvedSource);
   let schemaVersion = 0;
   try {
     sourceDb.exec("PRAGMA busy_timeout = 5000");
@@ -17663,7 +17787,7 @@ function backupDatabaseFile(sourcePath, targetPath, storeId) {
   } finally {
     sourceDb.close();
   }
-  const targetDb = new DatabaseSync2(resolvedTarget);
+  const targetDb = new DatabaseSync(resolvedTarget);
   try {
     targetDb.exec("PRAGMA busy_timeout = 5000");
     if (!checkIntegrity(targetDb)) {
@@ -17695,7 +17819,7 @@ function restoreDatabaseFile(backupPath, targetPath, storeId, expectedSchemaVers
   if (!backupStat || !backupStat.isFile() || backupStat.isSymbolicLink()) {
     throw databaseError("runtime_path_invalid", resolvedBackup, `backup database ${resolvedBackup} must be a regular file, not a link or directory`);
   }
-  const backupDb = new DatabaseSync2(resolvedBackup);
+  const backupDb = new DatabaseSync(resolvedBackup);
   let schemaVersion = 0;
   try {
     backupDb.exec("PRAGMA busy_timeout = 5000");
@@ -17735,7 +17859,7 @@ function restoreDatabaseFile(backupPath, targetPath, storeId, expectedSchemaVers
     chmodSync(resolvedTarget, 384);
   } catch {
   }
-  const targetDb = new DatabaseSync2(resolvedTarget);
+  const targetDb = new DatabaseSync(resolvedTarget);
   try {
     targetDb.exec("PRAGMA busy_timeout = 5000");
     if (!checkIntegrity(targetDb)) {
@@ -20377,7 +20501,7 @@ function compileStep(step, index, stepIndex, requirePlanHash, sink) {
   const maxAttempts = compileCountField(step.maxAttempts, 1, `${id}.maxAttempts`, id, sink);
   const timeoutMs = compileOptionalDuration(step.timeoutMs, `${id}.timeoutMs`, id, sink);
   const assignments = compileAssignments(step, id, agent, sink);
-  const join15 = compileJoin(step, id, sink);
+  const join17 = compileJoin(step, id, sink);
   const requiredEvidence = compileEvidence(step, id, sink);
   const transitions = compileTransitions(step, id, index, stepIndex, sink);
   const outcomes = Object.keys(transitions).sort(compareCodeUnits4);
@@ -20405,7 +20529,7 @@ function compileStep(step, index, stepIndex, requirePlanHash, sink) {
     transitions: orderedTransitions,
     requiresPlanHash: requirePlanHash.includes(id),
     assignments,
-    join: join15
+    join: join17
   };
   if (kind === "agent" || kind === "moa") {
     if (!agent) return void 0;
@@ -20455,15 +20579,15 @@ function compileAssignments(step, stepId, primaryAgentId, sink) {
   };
 }
 function compileJoin(step, stepId, sink) {
-  const join15 = objectValue2(step.join);
-  if (!join15) return { strategy: "all" };
-  const declared = stringValue2(join15.strategy);
+  const join17 = objectValue2(step.join);
+  if (!join17) return { strategy: "all" };
+  const declared = stringValue2(join17.strategy);
   const strategy = declared && JOIN_STRATEGIES.has(declared) ? declared : "all";
-  const minimumPassed = compileOptionalCount(join15.minimumPassed, `${stepId}.join.minimumPassed`, stepId, sink);
+  const minimumPassed = compileOptionalCount(join17.minimumPassed, `${stepId}.join.minimumPassed`, stepId, sink);
   const compiled = {
     strategy,
     ...minimumPassed !== void 0 ? { minimumPassed } : {},
-    ...typeof join15.cancelRemaining === "boolean" ? { cancelRemaining: join15.cancelRemaining } : {}
+    ...typeof join17.cancelRemaining === "boolean" ? { cancelRemaining: join17.cancelRemaining } : {}
   };
   return compiled;
 }
@@ -21758,12 +21882,12 @@ function enqueueVnextScheduledRun(storePath, runId, configRevision, bound, start
   if (owner.admitted.has(runId) || owner.queue.some((item) => item.runId === runId)) {
     return Promise.reject(runtimeError("run_busy", runId, `run ${runId} is already admitted or queued`));
   }
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     owner.queue.push({
       runId,
       configRevision,
       bound,
-      start: (token) => start(token).then(resolve8, reject),
+      start: (token) => start(token).then(resolve9, reject),
       fail: (error) => reject(error)
     });
     pump(storePath, owner);
@@ -22274,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);
@@ -22290,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);
@@ -22303,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);
@@ -22324,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,
@@ -22335,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;
@@ -22347,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),
@@ -22357,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
@@ -22912,6 +23058,43 @@ function evaluateArtifactsGate(context, definition) {
 // plugins/kxm/src/vnext-engine-command.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
+
+// plugins/kxm/src/safety-integrity.ts
+var DESTRUCTIVE_COMMAND_PATTERNS = Object.freeze([
+  /^\s*rm\s+.*-[a-zA-Z]*r[a-zA-Z]*f/i,
+  /^\s*rm\s+.*-[a-zA-Z]*f[a-zA-Z]*r/i,
+  /^\s*rm\s+.*(-[a-zA-Z]*r[a-zA-Z]*\s+.*-[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*\s+.*-[a-zA-Z]*r[a-zA-Z]*)/i,
+  /^\s*git\s+reset\s+--hard/i,
+  /^\s*git\s+clean\s+-[a-zA-Z]*f/i,
+  /^\s*git\s+checkout\s+--\s+/i,
+  /^\s*git\s+restore\s+(\.|\*|--staged\s+(\.|\*))/i
+]);
+function assertCommandSeatbelt(command) {
+  for (const pattern of DESTRUCTIVE_COMMAND_PATTERNS) {
+    if (pattern.test(command)) {
+      throw new Error(
+        `Command blocked by KXM safety seatbelt: "${command}". Destructive workspace mutations require explicit operator override.`
+      );
+    }
+  }
+}
+var INSECURE_SSH_HOST_KEY_PATTERNS = Object.freeze([
+  /StrictHostKeyChecking=(accept-new|no|off)/i,
+  /UserKnownHostsFile=\/dev\/null/i
+]);
+function assertPinnedSshHostKeyPolicy(sshArgs) {
+  for (const arg of sshArgs) {
+    for (const pattern of INSECURE_SSH_HOST_KEY_PATTERNS) {
+      if (pattern.test(arg)) {
+        throw new Error(
+          `Insecure SSH host key policy rejected: "${arg}". KXM headless SSH requires pinned host keys with StrictHostKeyChecking=yes and BatchMode=yes.`
+        );
+      }
+    }
+  }
+}
+
+// plugins/kxm/src/vnext-engine-command.ts
 var MAX_DIRECT_TIMER_MS = 2147483647;
 var COMMAND_TERM_GRACE_MS = 2e3;
 var COMMAND_FINAL_WAIT_MS = 2e3;
@@ -22997,8 +23180,8 @@ var CommandObserver = class {
     this.requestStop("error", "lost-close");
   }
   run() {
-    return new Promise((resolve8) => {
-      this.resolveOutcome = resolve8;
+    return new Promise((resolve9) => {
+      this.resolveOutcome = resolve9;
       try {
         this.start();
       } catch (error) {
@@ -23028,6 +23211,7 @@ var CommandObserver = class {
     if (!Number.isInteger(this.definition.timeoutMs) || this.definition.timeoutMs < 1 || this.definition.timeoutMs > MAX_DIRECT_TIMER_MS) {
       throw runtimeError("run_events_illegal", "command", "command timeoutMs exceeds the direct timer bound");
     }
+    assertCommandSeatbelt(this.definition.argv.join(" "));
     this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
     let child;
     try {
@@ -24153,6 +24337,7 @@ async function stepLocked(context, runId, producer, token) {
   return drivePanel(context, prepared.panel, producer);
 }
 async function runPreparedCommandGate(context, prepared, definition, token) {
+  assertCommandSeatbelt(definition.argv.join(" "));
   const storePath = context.eventStore.path;
   const observer = createCommandObserver({
     definition,
@@ -25930,6 +26115,24 @@ function createVnextOneShotProducer(options = {}) {
         "--output-format",
         "json"
       ];
+    } else if (harness === "agy") {
+      args = [
+        "-m",
+        resolved.model,
+        ...permissionArgs,
+        "--output-format",
+        "json",
+        "-p"
+      ];
+    } else if (harness === "kimi") {
+      args = [
+        "-m",
+        resolved.model,
+        ...permissionArgs,
+        "--output-format",
+        "stream-json",
+        "-p"
+      ];
     } else {
       throw new Error(`oneshot_harness_unsupported: ${harness} permission_profile_unaudited`);
     }
@@ -25972,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 = {
@@ -25984,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";
@@ -26409,8 +26614,8 @@ async function startVnextRuntimeSupervisorInner(paths, requestedPortOption, now)
             }
             let releaseActive = () => {
             };
-            const activePromise = new Promise((resolve8) => {
-              releaseActive = resolve8;
+            const activePromise = new Promise((resolve9) => {
+              releaseActive = resolve9;
             });
             activeDrives.set(runId, activePromise);
             const cleanupActive = () => {
@@ -26464,7 +26669,6 @@ async function startVnextRuntimeSupervisorInner(paths, requestedPortOption, now)
               });
             } catch (err) {
               earlyError = err;
-              drivePromise = Promise.reject(err);
             }
             await Promise.resolve();
             if (earlyError) {
@@ -26490,6 +26694,7 @@ async function startVnextRuntimeSupervisorInner(paths, requestedPortOption, now)
                 } catch {
                 }
               }
+            }).catch(() => {
             });
             sendJson(response, 202, {
               ok: true,
@@ -26866,8 +27071,8 @@ var PiSession = class {
     }
     const id = `cmd_${++this.commandCounter}`;
     const payload = { ...command, id };
-    return new Promise((resolve8, reject) => {
-      this.pendingCommands.set(id, { resolve: resolve8, reject });
+    return new Promise((resolve9, reject) => {
+      this.pendingCommands.set(id, { resolve: resolve9, reject });
       try {
         this.process.stdin.write(JSON.stringify(payload) + "\n");
       } catch (err) {
@@ -26888,7 +27093,7 @@ var PiSession = class {
       return { outcome, text: "aborted", usage: {} };
     }
     this.status = "busy";
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let signalCleanup;
       if (signal) {
         const onAbort = () => {
@@ -26902,7 +27107,7 @@ var PiSession = class {
         signalCleanup = () => signal.removeEventListener("abort", onAbort);
       }
       this.activePrompt = {
-        resolve: resolve8,
+        resolve: resolve9,
         reject,
         allowedOutcomes,
         text: "",
@@ -26975,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(", ")})`);
@@ -27063,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;
@@ -27627,21 +27834,1291 @@ function evaluatePromotionPolicy(candidate, policy = "manual_pr", options) {
     reason: `Unknown promotion policy: ${String(policy)}`
   };
 }
+
+// plugins/kxm/src/browser.ts
+import { execSync } from "node:child_process";
+var VIEWPORT_PRESETS = Object.freeze({
+  "mobile-sm": { name: "Mobile Small (SE)", category: "mobile", width: 375, height: 667, isMobile: true, hasTouch: true },
+  "mobile": { name: "Mobile (iPhone 16 / 15 Pro)", category: "mobile", width: 393, height: 852, isMobile: true, hasTouch: true },
+  "mobile-lg": { name: "Mobile Large (Pro Max)", category: "mobile", width: 430, height: 932, isMobile: true, hasTouch: true },
+  "pixel": { name: "Google Pixel 8/9", category: "mobile", width: 412, height: 924, isMobile: true, hasTouch: true },
+  "galaxy": { name: "Samsung Galaxy S24", category: "mobile", width: 360, height: 780, isMobile: true, hasTouch: true },
+  "tablet": { name: "Tablet (iPad Air / Mini)", category: "tablet", width: 820, height: 1180, isMobile: true, hasTouch: true },
+  "tablet-lg": { name: "Tablet Large (iPad Pro 12.9)", category: "tablet", width: 1024, height: 1366, isMobile: true, hasTouch: true },
+  "laptop": { name: "Standard Laptop", category: "laptop", width: 1366, height: 768 },
+  "macbook-13": { name: "MacBook Air 13", category: "laptop", width: 1440, height: 900 },
+  "macbook-16": { name: "MacBook Pro 16", category: "laptop", width: 1728, height: 1117 },
+  "desktop": { name: "Desktop FHD (1080p)", category: "desktop", width: 1920, height: 1080 },
+  "desktop-2k": { name: "Desktop QHD (1440p)", category: "desktop", width: 2560, height: 1440 },
+  "desktop-4k": { name: "Desktop 4K UHD", category: "desktop", width: 3840, height: 2160 }
+});
+function resolveViewportDimensions(presetOrDims) {
+  if (!presetOrDims) {
+    return { width: 1920, height: 1080 };
+  }
+  if (typeof presetOrDims === "string") {
+    const matched = VIEWPORT_PRESETS[presetOrDims.toLowerCase()];
+    if (matched) {
+      return { width: matched.width, height: matched.height };
+    }
+    return { width: 1920, height: 1080 };
+  }
+  return presetOrDims;
+}
+function resolvePassCliApiKey(execFn = (cmd) => execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"], timeout: 5e3 })) {
+  if (typeof process === "undefined" || process.env.USE_PASS_CLI === "false") {
+    return void 0;
+  }
+  if (process.env.PASS_CLI_OUTPUT_MOCK) {
+    try {
+      const parsed = JSON.parse(process.env.PASS_CLI_OUTPUT_MOCK);
+      const extraFields = parsed?.item?.content?.extra_fields || [];
+      const customSections = parsed?.item?.content?.content?.Custom?.sections || [];
+      const sectionFields = customSections.flatMap((s) => s.section_fields || []);
+      const allFields = [...extraFields, ...sectionFields];
+      return allFields.find((f) => f.name === "STEEL_API_KEY")?.content?.Hidden;
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    const output = execFn(
+      'pass-cli item view --vault-name "AI Provider Keys" --item-title "Steel Browser (KontextMind DOKS)" --output json'
+    );
+    const parsed = JSON.parse(output);
+    const extraFields = parsed?.item?.content?.extra_fields || [];
+    const customSections = parsed?.item?.content?.content?.Custom?.sections || [];
+    const sectionFields = customSections.flatMap((s) => s.section_fields || []);
+    const allFields = [...extraFields, ...sectionFields];
+    return allFields.find((f) => f.name === "STEEL_API_KEY")?.content?.Hidden;
+  } catch {
+    return void 0;
+  }
+}
+function resolveSteelConfig(overrides) {
+  const apiUrl = overrides?.apiUrl || process.env.STEEL_API_URL || "https://steel.kontextmind.com";
+  const apiKey = overrides?.apiKey || process.env.STEEL_API_KEY || resolvePassCliApiKey();
+  const uiUrl = overrides?.uiUrl || (overrides?.apiUrl ? `${overrides.apiUrl.replace(/\/$/, "")}/ui` : void 0) || process.env.STEEL_UI_URL || `${apiUrl.replace(/\/$/, "")}/ui`;
+  return {
+    apiUrl: apiUrl.replace(/\/$/, ""),
+    apiKey,
+    uiUrl,
+    timeoutMs: overrides?.timeoutMs || 3e5
+    // 5 minutes default
+  };
+}
+function formatCDPEndpoint(session, config) {
+  const baseApi = config.apiUrl;
+  const urlObj = new URL(baseApi);
+  const isSecure = urlObj.protocol === "https:";
+  const wsProtocol = isSecure ? "wss:" : "ws:";
+  const host = urlObj.host;
+  const searchParams = new URLSearchParams();
+  searchParams.set("sessionId", session.id);
+  if (config.apiKey) {
+    searchParams.set("apiKey", config.apiKey);
+  }
+  return `${wsProtocol}//${host}/v1/devtools?${searchParams.toString()}`;
+}
+function sanitizeLogOutput(input) {
+  if (typeof input === "string") {
+    return input.replace(/apiKey=[^&]+/g, "apiKey=[REDACTED]").replace(/steel_[a-f0-9]+/g, "steel_[REDACTED]");
+  }
+  if (Array.isArray(input)) {
+    return input.map(sanitizeLogOutput);
+  }
+  if (input !== null && typeof input === "object") {
+    const copy = {};
+    for (const [k, v] of Object.entries(input)) {
+      if (/key|secret|token|auth|password/i.test(k) && typeof v === "string") {
+        copy[k] = "[REDACTED]";
+      } else {
+        copy[k] = sanitizeLogOutput(v);
+      }
+    }
+    return copy;
+  }
+  return input;
+}
+function createAnnotationFeedback(feedback) {
+  return {
+    ...feedback,
+    capturedAt: feedback.capturedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatAnnotationFeedbackPrompt(feedback) {
+  let output = `## Visual Feedback & Section Annotation
+
+`;
+  output += `- **Target URL**: ${feedback.url}
+`;
+  if (feedback.sessionId) {
+    output += `- **Session ID**: ${feedback.sessionId}
+`;
+  }
+  if (feedback.sectionSelector) {
+    output += `- **Section Target Selector**: \`${feedback.sectionSelector}\`
+`;
+  }
+  if (feedback.screenshotPath) {
+    output += `- **Screenshot Artifact**: \`${feedback.screenshotPath}\`
+`;
+  }
+  output += `- **Captured At**: ${feedback.capturedAt}
+
+`;
+  output += `### Summary
+${feedback.overallSummary}
+
+`;
+  if (feedback.annotations.length > 0) {
+    output += `### Annotated Elements & Notes
+
+`;
+    feedback.annotations.forEach((item, idx) => {
+      output += `${idx + 1}. **${item.label}**`;
+      if (item.severity) {
+        output += ` [${item.severity.toUpperCase()}]`;
+      }
+      output += `
+   - **Note**: ${item.note}
+`;
+      if (item.selector) {
+        output += `   - **Selector**: \`${item.selector}\`
+`;
+      }
+      if (item.boundingBox) {
+        output += `   - **Region (Box)**: x=${item.boundingBox.x}, y=${item.boundingBox.y}, w=${item.boundingBox.width}, h=${item.boundingBox.height}
+`;
+      }
+    });
+    output += `
+`;
+  }
+  if (feedback.requestedChanges.length > 0) {
+    output += `### Actionable Change List
+
+`;
+    feedback.requestedChanges.forEach((change, idx) => {
+      output += `- [ ] ${change}
+`;
+    });
+  }
+  return output;
+}
+var SteelClient = class {
+  config;
+  activeSessions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = resolveSteelConfig(config);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  headers() {
+    const h = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      h["x-steel-api-key"] = this.config.apiKey;
+    }
+    return h;
+  }
+  /**
+   * Launch a new Steel browser session on DOKS.
+   */
+  async createSession(options) {
+    const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs ?? 3e5;
+    const body = {
+      timeout: timeoutMs
+    };
+    const dimensions = options?.dimensions || (options?.viewportPreset ? resolveViewportDimensions(options.viewportPreset) : void 0);
+    if (dimensions) {
+      body.dimensions = dimensions;
+    }
+    if (options?.userAgent) {
+      body.userAgent = options.userAgent;
+    }
+    if (options?.proxy) {
+      body.proxy = options.proxy;
+    }
+    const res = await fetch(`${this.config.apiUrl}/v1/sessions`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Failed to create Steel session (${res.status}): ${errText}`);
+    }
+    const data = await res.json();
+    const session = {
+      id: data.id,
+      createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+      status: "live",
+      state: "AGENT_CONTROL",
+      websocketUrl: data.websocketUrl || "",
+      debugUrl: data.debugUrl || "",
+      debuggerUrl: data.debuggerUrl || "",
+      sessionViewerUrl: data.sessionViewerUrl || `${this.config.uiUrl}?sessionId=${data.id}`,
+      timeoutMs,
+      lastActiveAt: Date.now(),
+      activeController: "agent",
+      userAgent: data.userAgent
+    };
+    this.activeSessions.set(session.id, session);
+    return session;
+  }
+  /**
+   * Get details of an existing session.
+   */
+  async getSession(sessionId) {
+    const res = await fetch(`${this.config.apiUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (res.status === 404) {
+      const cached = this.activeSessions.get(sessionId);
+      if (cached) {
+        cached.state = "EXPIRED";
+        cached.status = "released";
+        cached.activeController = "none";
+      }
+      return null;
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to fetch Steel session (${res.status})`);
+    }
+    const data = await res.json();
+    const existing = this.activeSessions.get(sessionId);
+    const session = {
+      id: data.id,
+      createdAt: data.createdAt,
+      status: data.status,
+      state: existing?.state ?? (data.status === "live" ? "AGENT_CONTROL" : "RELEASED"),
+      websocketUrl: data.websocketUrl || existing?.websocketUrl || "",
+      debugUrl: data.debugUrl || existing?.debugUrl || "",
+      debuggerUrl: data.debuggerUrl || existing?.debuggerUrl || "",
+      sessionViewerUrl: existing?.sessionViewerUrl || `${this.config.uiUrl}?sessionId=${data.id}`,
+      timeoutMs: data.timeout || existing?.timeoutMs || 3e5,
+      lastActiveAt: Date.now(),
+      activeController: existing?.activeController ?? (data.status === "live" ? "agent" : "none"),
+      userAgent: data.userAgent
+    };
+    this.activeSessions.set(session.id, session);
+    return session;
+  }
+  /**
+   * Request human takeover for MFA, login, or consent.
+   * Pauses agent automation and sets state to HUMAN_CONTROL.
+   */
+  requestHumanTakeover(sessionId, reason) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not tracked or already released`);
+    }
+    if (session.state === "RELEASED" || session.state === "EXPIRED" || session.state === "FAILED") {
+      throw new Error(`Cannot initiate takeover on session in state ${session.state}`);
+    }
+    session.state = "HUMAN_CONTROL";
+    session.activeController = "human";
+    session.takeoverReason = reason;
+    session.lastActiveAt = Date.now();
+    const takeoverUrl = `${this.config.uiUrl}?sessionId=${encodeURIComponent(sessionId)}`;
+    const instructions = `[HUMAN TAKEOVER REQUIRED]
+Reason: ${reason}
+Session ID: ${session.id}
+Takeover URL: ${takeoverUrl}
+
+Instructions for Operator:
+1. Open the URL above to access the session UI.
+2. Perform the required authentication / MFA / consent action.
+3. Return to the terminal and signal completion. Automation is paused until you confirm.`;
+    return {
+      session,
+      takeoverUrl,
+      instructions
+    };
+  }
+  /**
+   * Signal that human takeover is complete.
+   * Moves state to VERIFY_AUTHENTICATION before transitioning back to AGENT_CONTROL.
+   */
+  signalHumanComplete(sessionId) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not tracked or already released`);
+    }
+    if (session.state !== "HUMAN_CONTROL") {
+      throw new Error(`Session ${sessionId} is not in HUMAN_CONTROL state (currently ${session.state})`);
+    }
+    session.state = "VERIFY_AUTHENTICATION";
+    session.activeController = "agent";
+    session.lastActiveAt = Date.now();
+    return {
+      session,
+      state: session.state
+    };
+  }
+  /**
+   * Confirm authentication verification passed and restore AGENT_CONTROL.
+   */
+  confirmAuthenticationVerified(sessionId) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not tracked or already released`);
+    }
+    if (session.state !== "VERIFY_AUTHENTICATION") {
+      throw new Error(`Session ${sessionId} is not in VERIFY_AUTHENTICATION state (currently ${session.state})`);
+    }
+    session.state = "AGENT_CONTROL";
+    session.activeController = "agent";
+    session.takeoverReason = void 0;
+    session.lastActiveAt = Date.now();
+    return session;
+  }
+  /**
+   * Gracefully release a session.
+   */
+  async releaseSession(sessionId) {
+    try {
+      const res = await fetch(`${this.config.apiUrl}/v1/sessions/${encodeURIComponent(sessionId)}/release`, {
+        method: "POST",
+        headers: this.headers()
+      });
+      const session = this.activeSessions.get(sessionId);
+      if (session) {
+        session.status = "released";
+        session.state = "RELEASED";
+        session.activeController = "none";
+      }
+      this.activeSessions.delete(sessionId);
+      return res.ok;
+    } catch {
+      this.activeSessions.delete(sessionId);
+      return false;
+    }
+  }
+  /**
+   * Perform a direct stateless scrape without manual session management.
+   */
+  async scrape(url) {
+    const res = await fetch(`${this.config.apiUrl}/v1/scrape`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ url })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Scrape failed (${res.status}): ${err}`);
+    }
+    return res.json();
+  }
+  /**
+   * Perform a direct screenshot action.
+   */
+  async screenshot(url, fullPage = false) {
+    const res = await fetch(`${this.config.apiUrl}/v1/screenshot`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ url, fullPage })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Screenshot failed (${res.status}): ${err}`);
+    }
+    return res.json();
+  }
+  /**
+   * Detect and list orphaned or timed-out active sessions.
+   */
+  async checkOrphanedSessions(maxIdleMs = 6e5) {
+    const res = await fetch(`${this.config.apiUrl}/v1/sessions`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!res.ok) {
+      return [];
+    }
+    const data = await res.json();
+    const remoteSessions = data.sessions || [];
+    const now = Date.now();
+    const orphaned = [];
+    for (const rs of remoteSessions) {
+      if (rs.status === "live" || rs.status === "idle") {
+        const tracked = this.activeSessions.get(rs.id);
+        if (!tracked && rs.duration > maxIdleMs) {
+          orphaned.push(rs.id);
+        } else if (tracked && now - tracked.lastActiveAt > maxIdleMs && tracked.state !== "HUMAN_CONTROL") {
+          orphaned.push(rs.id);
+        }
+      }
+    }
+    return orphaned;
+  }
+};
+
+// plugins/kxm/src/modes.ts
+var import_yaml6 = __toESM(require_dist(), 1);
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { join as join15 } from "node:path";
+var DEFAULT_MODES_CONFIG = Object.freeze({
+  schema: "kxm.modes.v1",
+  majorModes: {
+    coder: {
+      description: "First-pass implementation, bug fixing, and test authoring",
+      baseTools: ["read", "edit", "write", "bash"],
+      contextFiles: ["AGENTS.md"],
+      thinkingLevel: "medium",
+      model: "grok/grok-4.6"
+    },
+    planner: {
+      description: "High-level architectural planning, scoping, and decomposition",
+      baseTools: ["read", "grep", "find"],
+      contextFiles: ["plans/implementation-plan.md"],
+      thinkingLevel: "high",
+      model: "claude/fable"
+    },
+    auditor: {
+      description: "Security, compliance, and code quality verification",
+      baseTools: ["read", "grep"],
+      contextFiles: ["SECURITY.md"],
+      thinkingLevel: "high",
+      model: "codex/gpt-5.6-sol"
+    },
+    browser: {
+      description: "Web application exploration, screenshotting, and UI testing",
+      baseTools: ["read", "bash"],
+      contextFiles: ["docs/browser-automation.md"],
+      thinkingLevel: "medium",
+      model: "grok/grok-4.6"
+    }
+  },
+  domains: {
+    git: {
+      description: "Git version control operations",
+      tools: ["git_status", "git_diff", "git_commit"],
+      promptSnippet: "Follow git branch conventions; never commit directly to main."
+    },
+    k8s: {
+      description: "Kubernetes cluster inspection and deployment",
+      tools: ["kubectl_get", "kubectl_describe"],
+      promptSnippet: "Target local dev cluster; verify namespaces before mutating."
+    },
+    database: {
+      description: "Database queries and schema verification",
+      tools: ["sqlite_query", "sqlite_schema"],
+      promptSnippet: "Database is SQLite at .kxm/state/kxm.db; use read-only queries."
+    },
+    browser: {
+      description: "Remote Steel browser sessions and visual testing",
+      tools: ["steel_session", "steel_scrape", "steel_screenshot"],
+      promptSnippet: "Use Steel on DOKS for browser automation; invoke takeover on MFA."
+    }
+  }
+});
+function estimateTokens(charCount) {
+  return Math.ceil(charCount / 3.8);
+}
+function loadModesConfig(projectRoot) {
+  if (!projectRoot) {
+    return DEFAULT_MODES_CONFIG;
+  }
+  const modesPath = join15(projectRoot, ".kxm", "modes.yaml");
+  if (!existsSync12(modesPath)) {
+    return DEFAULT_MODES_CONFIG;
+  }
+  try {
+    const raw = readFileSync10(modesPath, "utf8");
+    const parsed = (0, import_yaml6.parse)(raw);
+    if (parsed && parsed.schema === "kxm.modes.v1" && parsed.majorModes) {
+      return {
+        schema: "kxm.modes.v1",
+        majorModes: { ...DEFAULT_MODES_CONFIG.majorModes, ...parsed.majorModes },
+        domains: { ...DEFAULT_MODES_CONFIG.domains, ...parsed.domains }
+      };
+    }
+  } catch {
+  }
+  return DEFAULT_MODES_CONFIG;
+}
+function resolveActiveMode(config, majorModeName = "coder", domainNames = []) {
+  const major = config.majorModes[majorModeName] || config.majorModes["coder"] || DEFAULT_MODES_CONFIG.majorModes["coder"];
+  const tools = new Set(major.baseTools);
+  const contextFiles = new Set(major.contextFiles || []);
+  const promptSnippets = [];
+  const enabledDomains = [];
+  if (config.domains) {
+    for (const dName of domainNames) {
+      const d = config.domains[dName.toLowerCase().trim()];
+      if (d) {
+        enabledDomains.push(dName.toLowerCase().trim());
+        d.tools.forEach((t) => tools.add(t));
+        (d.contextFiles || []).forEach((f) => contextFiles.add(f));
+        if (d.promptSnippet) {
+          promptSnippets.push(d.promptSnippet);
+        }
+      }
+    }
+  }
+  return {
+    majorMode: majorModeName,
+    enabledDomains,
+    tools: Array.from(tools),
+    contextFiles: Array.from(contextFiles),
+    promptSnippets,
+    thinkingLevel: major.thinkingLevel,
+    model: major.model || "grok/grok-4.6"
+  };
+}
+function calculatePromptFootprint(resolved, projectRoot = process.cwd(), catalog) {
+  const breakdown = [];
+  const baseSystemPromptChars = 3200;
+  breakdown.push({
+    name: `Base System Prompt (${resolved.majorMode})`,
+    chars: baseSystemPromptChars,
+    estimatedTokens: estimateTokens(baseSystemPromptChars)
+  });
+  for (const relPath of resolved.contextFiles) {
+    const fullPath = join15(projectRoot, relPath);
+    let chars = 0;
+    if (existsSync12(fullPath)) {
+      try {
+        chars = readFileSync10(fullPath, "utf8").length;
+      } catch {
+        chars = 0;
+      }
+    }
+    if (chars === 0) {
+      chars = 1500;
+    }
+    breakdown.push({
+      name: `Context File: ${relPath}`,
+      chars,
+      estimatedTokens: estimateTokens(chars)
+    });
+  }
+  if (resolved.promptSnippets.length > 0) {
+    const snippetChars = resolved.promptSnippets.join("\n").length;
+    breakdown.push({
+      name: `Domain Prompts (${resolved.enabledDomains.join(", ")})`,
+      chars: snippetChars,
+      estimatedTokens: estimateTokens(snippetChars)
+    });
+  }
+  const toolSchemaChars = resolved.tools.length * 650;
+  breakdown.push({
+    name: `Tool Schemas (${resolved.tools.length} active tools)`,
+    chars: toolSchemaChars,
+    estimatedTokens: estimateTokens(toolSchemaChars)
+  });
+  const totalChars = breakdown.reduce((sum, item) => sum + item.chars, 0);
+  const totalTokens = breakdown.reduce((sum, item) => sum + item.estimatedTokens, 0);
+  const maxContextWindow = 2e5;
+  const contextWindowRatio = Math.round(totalTokens / maxContextWindow * 1e3) / 10;
+  const cat = catalog || loadPriceCatalog(projectRoot);
+  const rawModel = resolved.model || "grok/grok-4.6";
+  const [prov, mod] = rawModel.includes("/") ? rawModel.split("/", 2) : [void 0, rawModel];
+  const inputCost = cat ? calculateModelCost(cat, {
+    model: mod || rawModel,
+    ...prov !== void 0 ? { provider: prov } : {},
+    tokensIn: totalTokens,
+    tokensOut: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  }) : void 0;
+  const cacheReadCost = cat ? calculateModelCost(cat, {
+    model: mod || rawModel,
+    ...prov !== void 0 ? { provider: prov } : {},
+    tokensIn: 0,
+    tokensOut: 0,
+    cacheReadTokens: totalTokens,
+    cacheWriteTokens: 0
+  }) : void 0;
+  const outputEstimateCost = cat ? calculateModelCost(cat, {
+    model: mod || rawModel,
+    ...prov !== void 0 ? { provider: prov } : {},
+    tokensIn: 0,
+    tokensOut: 1e3,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  }) : void 0;
+  return {
+    majorMode: resolved.majorMode,
+    enabledDomains: resolved.enabledDomains,
+    model: resolved.model || "grok/grok-4.6",
+    breakdown,
+    totalChars,
+    totalTokens,
+    contextWindowRatio,
+    projectedCost: {
+      inputCostUsd: inputCost?.costUsd ?? null,
+      cacheReadCostUsd: cacheReadCost?.costUsd ?? null,
+      outputCostEstimateUsd: outputEstimateCost?.costUsd ?? null
+    }
+  };
+}
+function formatModesExplainReport(footprint) {
+  const divider = "\u2550".repeat(60);
+  const subDivider = "\u2500".repeat(60);
+  let out = `
+${divider}
+`;
+  out += `KXM PRE-FLIGHT CONTEXT EXPLAIN
+`;
+  out += `${divider}
+`;
+  out += `Major Mode:       ${footprint.majorMode}
+`;
+  out += `Enabled Domains:  ${footprint.enabledDomains.length > 0 ? footprint.enabledDomains.join(", ") : "(none)"}
+`;
+  out += `Target Model:     ${footprint.model}
+
+`;
+  out += `CONTEXT BREAKDOWN:
+`;
+  for (const item of footprint.breakdown) {
+    const padName = item.name.padEnd(38, " ");
+    const tokenStr = `${item.estimatedTokens.toLocaleString()} tokens`.padStart(16, " ");
+    out += `  \u2022 ${padName} ${tokenStr}
+`;
+  }
+  out += `${subDivider}
+`;
+  const totalPad = `TOTAL PROMPT FOOTPRINT:`.padEnd(38, " ");
+  const totalStr = `${footprint.totalTokens.toLocaleString()} tokens`.padStart(16, " ");
+  out += `  ${totalPad} ${totalStr} (${footprint.contextWindowRatio}% of 200k window)
+
+`;
+  out += `PROJECTED COSTS (per turn):
+`;
+  out += `  \u2022 Initial Turn Input Cost:   ${footprint.projectedCost.inputCostUsd !== null ? `$${footprint.projectedCost.inputCostUsd.toFixed(4)}` : "unmetered/unknown"}
+`;
+  out += `  \u2022 Subsequent Cache-Read Cost: ${footprint.projectedCost.cacheReadCostUsd !== null ? `$${footprint.projectedCost.cacheReadCostUsd.toFixed(4)} (approx 90% savings)` : "unmetered/unknown"}
+`;
+  out += `  \u2022 Output Estimate (1k tokens): ${footprint.projectedCost.outputCostEstimateUsd !== null ? `$${footprint.projectedCost.outputCostEstimateUsd.toFixed(4)}` : "unmetered/unknown"}
+`;
+  out += `${divider}
+`;
+  return out;
+}
+
+// plugins/kxm/src/ssh-remote.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync11, readdirSync as readdirSync5, rmSync as rmSync2, statSync as statSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join16, resolve as resolve8 } from "node:path";
+var MAX_SSH_OUTPUT_BYTES = 50 * 1024;
+var MAX_SSH_OUTPUT_LINES = 2e3;
+var DEFAULT_SOCKET_DIR = ".kxm/run/ssh-sockets";
+var DEFAULT_CONTROL_PERSIST = "10m";
+function truncateSshOutput(raw) {
+  let text = raw;
+  let truncated = false;
+  if (Buffer.byteLength(text, "utf-8") > MAX_SSH_OUTPUT_BYTES) {
+    const buf = Buffer.from(text, "utf-8");
+    text = buf.subarray(0, MAX_SSH_OUTPUT_BYTES).toString("utf-8");
+    truncated = true;
+  }
+  const lines = text.split("\n");
+  if (lines.length > MAX_SSH_OUTPUT_LINES) {
+    text = lines.slice(0, MAX_SSH_OUTPUT_LINES).join("\n");
+    truncated = true;
+  }
+  if (truncated) {
+    text += `
+
+[kxm: ssh output truncated to ${MAX_SSH_OUTPUT_BYTES / 1024}KB / ${MAX_SSH_OUTPUT_LINES} lines]`;
+  }
+  return { text, truncated };
+}
+function parseSshConfig(configPath) {
+  const targetPath = configPath ?? join16(homedir2(), ".ssh", "config");
+  if (!existsSync13(targetPath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync11(targetPath, "utf-8");
+    const lines = content.split("\n");
+    const hosts = [];
+    let currentHosts = [];
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const spaceIdx = line.search(/\s/);
+      if (spaceIdx === -1) continue;
+      const key = line.slice(0, spaceIdx).trim().toLowerCase();
+      const value = line.slice(spaceIdx + 1).trim();
+      if (key === "host") {
+        const aliases = value.split(/\s+/).filter((a) => a !== "*");
+        currentHosts = [];
+        for (const alias of aliases) {
+          const entry = { alias, identityFiles: [] };
+          currentHosts.push(entry);
+          hosts.push(entry);
+        }
+      } else if (currentHosts.length > 0) {
+        for (const currentHost of currentHosts) {
+          if (key === "hostname") {
+            currentHost.hostName = value;
+          } else if (key === "user") {
+            currentHost.user = value;
+          } else if (key === "port") {
+            const p = Number.parseInt(value, 10);
+            if (!Number.isNaN(p)) currentHost.port = p;
+          } else if (key === "proxyjump") {
+            currentHost.proxyJump = value;
+          } else if (key === "identityfile") {
+            currentHost.identityFiles = currentHost.identityFiles ?? [];
+            currentHost.identityFiles.push(value);
+          }
+        }
+      }
+    }
+    return hosts;
+  } catch {
+    return [];
+  }
+}
+function resolveSshHostG(host, execFn = spawnSync3) {
+  try {
+    const result = execFn("ssh", ["-G", host], { encoding: "utf-8" });
+    if (result.status !== 0 || !result.stdout) {
+      return { alias: host, hostName: host };
+    }
+    const lines = String(result.stdout).split("\n");
+    const info = { alias: host, identityFiles: [] };
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx === -1) continue;
+      const key = line.slice(0, spaceIdx).toLowerCase();
+      const value = line.slice(spaceIdx + 1).trim();
+      if (key === "hostname") {
+        info.hostName = value;
+      } else if (key === "user") {
+        info.user = value;
+      } else if (key === "port") {
+        const p = Number.parseInt(value, 10);
+        if (!Number.isNaN(p)) info.port = p;
+      } else if (key === "proxyjump") {
+        if (value && value !== "none") info.proxyJump = value;
+      } else if (key === "identityfile") {
+        info.identityFiles = info.identityFiles ?? [];
+        info.identityFiles.push(value);
+      }
+    }
+    return info;
+  } catch {
+    return { alias: host, hostName: host };
+  }
+}
+function ensureSocketDir(socketDir = DEFAULT_SOCKET_DIR) {
+  const resolved = resolve8(socketDir);
+  if (!existsSync13(resolved)) {
+    mkdirSync7(resolved, { recursive: true, mode: 448 });
+  }
+  return resolved;
+}
+function buildSshArgs(options) {
+  const socketDir = ensureSocketDir(options.socketDir ?? DEFAULT_SOCKET_DIR);
+  const controlPath = join16(socketDir, "%C");
+  const persist2 = options.controlPersist ?? DEFAULT_CONTROL_PERSIST;
+  const args = [
+    "-o",
+    `ControlMaster=auto`,
+    "-o",
+    `ControlPath=${controlPath}`,
+    "-o",
+    `ControlPersist=${persist2}`
+  ];
+  if (options.batchMode !== false) {
+    args.push("-o", "BatchMode=yes");
+  }
+  if (options.strictHostKey !== false) {
+    args.push("-o", "StrictHostKeyChecking=yes");
+  }
+  if (options.extraArgs) {
+    args.push(...options.extraArgs);
+  }
+  assertPinnedSshHostKeyPolicy(args);
+  args.push(options.host);
+  return args;
+}
+function checkControlSocket(host, socketDir = DEFAULT_SOCKET_DIR, execFn = spawnSync3) {
+  const resolvedDir = ensureSocketDir(socketDir);
+  const controlPath = join16(resolvedDir, "%C");
+  try {
+    const result = execFn("ssh", ["-O", "check", "-o", `ControlPath=${controlPath}`, host], {
+      encoding: "utf-8"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function closeControlSocket(host, socketDir = DEFAULT_SOCKET_DIR, execFn = spawnSync3) {
+  const resolvedDir = ensureSocketDir(socketDir);
+  const controlPath = join16(resolvedDir, "%C");
+  try {
+    const result = execFn("ssh", ["-O", "stop", "-o", `ControlPath=${controlPath}`, host], {
+      encoding: "utf-8"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function pruneSocketDir(socketDir = DEFAULT_SOCKET_DIR) {
+  const resolvedDir = ensureSocketDir(socketDir);
+  let removed = 0;
+  try {
+    const entries = readdirSync5(resolvedDir);
+    for (const entry of entries) {
+      const fullPath = join16(resolvedDir, entry);
+      try {
+        const stat = statSync4(fullPath);
+        if (stat.isSocket()) {
+          rmSync2(fullPath, { force: true });
+          removed++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return removed;
+}
+function executeSshRun(params) {
+  const startTime = Date.now();
+  const execSyncFn = params.execFn ?? spawnSync3;
+  if (params.action === "info") {
+    if (params.host) {
+      const hostInfo = resolveSshHostG(params.host, execSyncFn);
+      return {
+        ok: true,
+        action: "info",
+        host: params.host,
+        resolvedHost: hostInfo.hostName ?? params.host,
+        user: hostInfo.user,
+        port: hostInfo.port,
+        hosts: [hostInfo],
+        durationMs: Date.now() - startTime
+      };
+    }
+    const discovered = parseSshConfig();
+    return {
+      ok: true,
+      action: "info",
+      hosts: discovered,
+      durationMs: Date.now() - startTime
+    };
+  }
+  if (!params.host) {
+    return {
+      ok: false,
+      action: params.action,
+      error: 'Parameter "host" is required for command and file actions.',
+      durationMs: Date.now() - startTime
+    };
+  }
+  const host = params.host;
+  const socketDir = params.socket_dir ?? DEFAULT_SOCKET_DIR;
+  const wasSocketActive = checkControlSocket(host, socketDir, execSyncFn);
+  if (params.action === "command") {
+    if (!params.command) {
+      return {
+        ok: false,
+        action: "command",
+        host,
+        error: 'Parameter "command" is required for command action.',
+        durationMs: Date.now() - startTime
+      };
+    }
+    try {
+      assertCommandSeatbelt(params.command);
+    } catch (err) {
+      return {
+        ok: false,
+        action: "command",
+        host,
+        error: err.message,
+        durationMs: Date.now() - startTime
+      };
+    }
+    let remoteCommand = params.command;
+    let inputStdin = void 0;
+    if (params.sudo) {
+      const sudoPwd = params.sudo_password ?? params.password;
+      if (sudoPwd) {
+        inputStdin = `${sudoPwd}
+`;
+        remoteCommand = `sudo -S -p '' -- sh -c ${JSON.stringify(params.command)}`;
+      } else {
+        remoteCommand = `sudo -- sh -c ${JSON.stringify(params.command)}`;
+      }
+    }
+    const useSshPass = Boolean(params.password);
+    const sshArgs = buildSshArgs({
+      host,
+      socketDir,
+      controlPersist: params.control_persist,
+      batchMode: !useSshPass,
+      strictHostKey: params.strict_host_key
+    });
+    sshArgs.push("--", remoteCommand);
+    const spawnEnv = { ...process.env };
+    let binary = "ssh";
+    let finalArgs = sshArgs;
+    if (useSshPass && params.password) {
+      binary = "sshpass";
+      finalArgs = ["-e", "ssh", ...sshArgs];
+      spawnEnv.SSHPASS = params.password;
+    }
+    try {
+      const result = execSyncFn(binary, finalArgs, {
+        encoding: "utf-8",
+        env: spawnEnv,
+        input: inputStdin,
+        timeout: params.timeout_ms ?? 12e4,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const stdoutRaw = String(result.stdout || "");
+      const stderrRaw = String(result.stderr || "");
+      const sanitizedStderr = stderrRaw.replace(/\[sudo\] password for [^:]+:\s*/gi, "");
+      const stdoutTrunc = truncateSshOutput(stdoutRaw);
+      const stderrTrunc = truncateSshOutput(sanitizedStderr);
+      return {
+        ok: result.status === 0,
+        action: "command",
+        host,
+        exitCode: result.status ?? 1,
+        stdout: stdoutTrunc.text,
+        stderr: stderrTrunc.text,
+        truncated: stdoutTrunc.truncated || stderrTrunc.truncated,
+        socketReused: wasSocketActive,
+        durationMs: Date.now() - startTime,
+        error: result.error ? result.error.message : void 0
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        action: "command",
+        host,
+        error: err.message,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  if (params.action === "file") {
+    if (!params.file_path) {
+      return {
+        ok: false,
+        action: "file",
+        host,
+        error: 'Parameter "file_path" is required for file action.',
+        durationMs: Date.now() - startTime
+      };
+    }
+    const filePath = params.file_path;
+    const op = params.file_op ?? "write";
+    if (op === "read") {
+      const readCmd = params.sudo ? `sudo cat ${JSON.stringify(filePath)}` : `cat ${JSON.stringify(filePath)}`;
+      return executeSshRun({
+        ...params,
+        action: "command",
+        command: readCmd
+      });
+    }
+    const content = params.file_content ?? "";
+    const redirectOp = op === "append" ? ">>" : ">";
+    const writeCmd = params.sudo ? `sudo tee ${op === "append" ? "-a " : ""}${JSON.stringify(filePath)} > /dev/null` : `cat ${redirectOp} ${JSON.stringify(filePath)}`;
+    const useSshPass = Boolean(params.password);
+    const sshArgs = buildSshArgs({
+      host,
+      socketDir,
+      controlPersist: params.control_persist,
+      batchMode: !useSshPass,
+      strictHostKey: params.strict_host_key
+    });
+    sshArgs.push("--", writeCmd);
+    const spawnEnv = { ...process.env };
+    let binary = "ssh";
+    let finalArgs = sshArgs;
+    if (useSshPass && params.password) {
+      binary = "sshpass";
+      finalArgs = ["-e", "ssh", ...sshArgs];
+      spawnEnv.SSHPASS = params.password;
+    }
+    try {
+      const result = execSyncFn(binary, finalArgs, {
+        encoding: "utf-8",
+        env: spawnEnv,
+        input: content,
+        timeout: params.timeout_ms ?? 6e4
+      });
+      return {
+        ok: result.status === 0,
+        action: "file",
+        host,
+        exitCode: result.status ?? 1,
+        stdout: String(result.stdout || ""),
+        stderr: String(result.stderr || ""),
+        fileProcessed: filePath,
+        bytesProcessed: Buffer.byteLength(content, "utf-8"),
+        socketReused: wasSocketActive,
+        durationMs: Date.now() - startTime,
+        error: result.error ? result.error.message : void 0
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        action: "file",
+        host,
+        error: err.message,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  return {
+    ok: false,
+    action: params.action,
+    error: `Unknown action: ${params.action}`,
+    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,
   CANDIDATE_SCHEMA,
+  DEFAULT_CONTROL_PERSIST,
   DEFAULT_HARNESS,
   DEFAULT_LOG_MAX_BYTES,
   DEFAULT_LOG_MAX_FILES,
+  DEFAULT_MODES_CONFIG,
+  DEFAULT_SOCKET_DIR,
+  DEFAULT_SUBAGENT_MODELS,
   IMPROVEMENT_REPORT_SCHEMA,
   IMPROVEMENT_REPORT_V1_SCHEMA,
   LOG_LEVEL_PRIORITY,
+  MAX_SSH_OUTPUT_BYTES,
+  MAX_SSH_OUTPUT_LINES,
   NATIVE_HARNESS_PROVIDERS,
   PI_ALLOWED_PROVIDERS,
   PI_NATIVE_BRAKE_PROVIDERS,
   PiSession,
   SAFE_HARNESS_COMMAND_ID,
+  SUBAGENT_TYPES,
+  SteelClient,
+  SubagentManager,
+  VIEWPORT_PRESETS,
   VNEXT_ABSENT_MEMORY_REVISION,
   VNEXT_EVENT_STORE_SCHEMA_VERSION,
   VNEXT_REGISTRY_SCHEMA_VERSION,
@@ -27654,15 +29131,20 @@ export {
   assertVnextConfigError,
   backupDatabaseFile,
   buildImprovementReport,
+  buildSshArgs,
+  calculatePromptFootprint,
   cancelVnextRun,
+  checkControlSocket,
   checkIntegrity,
   checkMemoryRevisionDrift,
   checkedParent,
   checkpointWal,
   classifyCandidateKind,
+  closeControlSocket,
   closeVnextRuntimeContext,
   computeGateEvidenceOutcome,
   computeVnextMemoryRevision,
+  createAnnotationFeedback,
   createBackup,
   createLogger,
   createVnextOneShotProducer,
@@ -27671,15 +29153,21 @@ export {
   defaultSpawn,
   discoverProjectStores,
   eligibleHarnesses,
+  ensureSocketDir,
   ensureVnextSupervisor,
   ensureWalJournalMode,
+  estimateTokens,
   evaluatePromotionPolicy,
+  executeSshRun,
   fileSha256,
   findWinNpmInnerExe,
   foldStoredVnextRun,
+  formatAnnotationFeedbackPrompt,
+  formatCDPEndpoint,
   formatHarnessInventory,
   formatHarnessUpdate,
   formatImprovementReport,
+  formatModesExplainReport,
   formatPiSessionDisplayName,
   formatPiSessionKey,
   gateRowContentHash,
@@ -27691,6 +29179,8 @@ export {
   isKnownHarnessId,
   isVnextRuntimeContextClosed,
   isWindowsHarnessShim,
+  loadModesConfig,
+  narrowSubagentTools,
   newVnextAssignmentId,
   newVnextAttemptId,
   newVnextCommandId,
@@ -27708,26 +29198,37 @@ export {
   parseGenericOneShotUsage,
   parseGrokOneShotUsage,
   parseKimiOneShotUsage,
+  parseSshConfig,
   persistVnextRunState,
   planHarnessUpdate,
   probeHarnessAssignment,
   probeHarnessAssignmentAsync,
   probeHarnesses,
+  probeHarnessesAsync,
   probeHarnessesForModel,
+  probeHarnessesForModelAsync,
   projectRuntimeKey,
+  pruneSocketDir,
   readVnextRunStatus,
   readVnextSupervisorToken,
   rebuildVnextRunProjection,
   redactLogValue,
   registerVnextRuntimeCloseHook,
+  resolveActiveMode,
   resolveDispatchStatus,
+  resolvePassCliApiKey,
+  resolveSshHostG,
+  resolveSteelConfig,
+  resolveViewportDimensions,
   restoreBackup,
   restoreDatabaseFile,
   rotateLogFiles,
   runHarnessUpdate,
   runtimeError,
+  sanitizeLogOutput,
   startVnextRuntimeSupervisor,
   tableColumns,
+  truncateSshOutput,
   userTables,
   validateHarnessModelPair,
   verifyExpectedTables,