@kontextmind/kxm 0.7.0 → 0.7.10

package/plugins/kxm/src/subagent-control.ts

@@ -0,0 +1,312 @@
+/**
+ * Supervisory agent control, in-process real-time steering, and work-splitting.
+ *
+ * Implements:
+ * - Dual-tool control plane: `agent` (spawn) and `agent_control` (manage, poll, steer, stop).
+ * - Strict capability narrowing via `allowed_tools[]` allowlists.
+ * - Mid-flight steering instruction injection.
+ * - Subagent state lifecycle management (working, blocked, idle, done, error).
+ */
+
+import { randomUUID } from "node:crypto";
+import { assertCommandSeatbelt } from "./safety-integrity.ts";
+
+export type SubagentType = "general" | "Explore" | "Plan" | "Reviewer" | "Auditor";
+export type SubagentStatus = "pending" | "running" | "blocked" | "completed" | "stopped" | "failed";
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high";
+
+export interface AgentSpawnParams {
+  prompt: string;
+  description: string;
+  type?: SubagentType | undefined;
+  model?: string | undefined;
+  thinking?: ThinkingLevel | undefined;
+  allowed_tools?: string[] | undefined;
+  turns?: number | undefined;
+  background?: boolean | undefined;
+  parent_tools?: readonly string[] | undefined;
+}
+
+export interface AgentControlParams {
+  action: "info" | "result" | "steer" | "stop";
+  kind?: "types" | "models" | "active" | undefined;
+  agent_id?: string | undefined;
+  message?: string | undefined;
+  turns?: number | undefined;
+  verbose?: boolean | undefined;
+}
+
+export interface SubagentRecord {
+  id: string;
+  description: string;
+  type: SubagentType;
+  model: string;
+  thinking: ThinkingLevel;
+  allowedTools: string[];
+  status: SubagentStatus;
+  turnsMax: number;
+  turnsCompleted: number;
+  prompt: string;
+  createdAt: string;
+  updatedAt: string;
+  steeringMessages: Array<{ text: string; injectedAt: string; processed: boolean }>;
+  output?: string | undefined;
+  error?: string | undefined;
+}
+
+export interface SubagentExecutionReceipt {
+  ok: boolean;
+  action: string;
+  agent_id?: string | undefined;
+  status?: SubagentStatus | undefined;
+  activeAgents?: Array<{ id: string; description: string; type: SubagentType; status: SubagentStatus }> | undefined;
+  types?: readonly SubagentType[] | undefined;
+  result?: string | undefined;
+  steered?: boolean | undefined;
+  stopped?: boolean | undefined;
+  error?: string | undefined;
+}
+
+export const SUBAGENT_TYPES: readonly SubagentType[] = Object.freeze([
+  "general",
+  "Explore",
+  "Plan",
+  "Reviewer",
+  "Auditor",
+]);
+
+export const DEFAULT_SUBAGENT_MODELS: Readonly<Record<SubagentType, string>> = 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",
+});
+
+/**
+ * Validates and intersects child allowed tools against the parent tool surface.
+ * Enforces the safety invariant that a child can only narrow, never expand authority.
+ */
+export function narrowSubagentTools(
+  requestedTools: readonly string[] | undefined,
+  parentTools?: readonly string[] | undefined,
+): string[] {
+  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: string[] = [];
+
+  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;
+}
+
+/**
+ * In-Process Subagent Manager.
+ */
+export class SubagentManager {
+  private readonly subagents = new Map<string, SubagentRecord>();
+
+  /**
+   * Spawns a new managed subagent with strict capability boundaries.
+   */
+  spawn(params: AgentSpawnParams): SubagentRecord {
+    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_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+    const now = new Date().toISOString();
+
+    const record: SubagentRecord = {
+      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, record);
+    return record;
+  }
+
+  /**
+   * Dispatches an action from the `agent_control` tool.
+   */
+  control(params: AgentControlParams): SubagentExecutionReceipt {
+    const action = params.action;
+
+    // 1. Action: "info"
+    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.`,
+      };
+    }
+
+    // 2. Action: "result"
+    if (action === "result") {
+      return {
+        ok: true,
+        action: "result",
+        agent_id: agent.id,
+        status: agent.status,
+        result: agent.output ?? `[Subagent is currently ${agent.status}]`,
+      };
+    }
+
+    // 3. Action: "steer"
+    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: new Date().toISOString(),
+        processed: false,
+      });
+      agent.updatedAt = new Date().toISOString();
+
+      return {
+        ok: true,
+        action: "steer",
+        agent_id: agent.id,
+        status: agent.status,
+        steered: true,
+      };
+    }
+
+    // 4. Action: "stop"
+    if (action === "stop") {
+      agent.status = "stopped";
+      agent.updatedAt = 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: string): SubagentRecord | undefined {
+    return this.subagents.get(agentId);
+  }
+
+  /**
+   * Marks a subagent as completed with output.
+   */
+  complete(agentId: string, output: string): void {
+    const agent = this.subagents.get(agentId);
+    if (agent) {
+      agent.status = "completed";
+      agent.output = output;
+      agent.updatedAt = new Date().toISOString();
+    }
+  }
+
+  /**
+   * Returns all active running subagents.
+   */
+  listActive(): SubagentRecord[] {
+    return Array.from(this.subagents.values()).filter(
+      (ag) => ag.status === "running" || ag.status === "pending" || ag.status === "blocked",
+    );
+  }
+}

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

@@ -15,7 +15,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { DatabaseSync } from "node:sqlite";
+import { DatabaseSync } from "./sqlite.ts";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import {
   VnextConfigError,

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

@@ -1033,6 +1033,7 @@ function validateBundle(
   environments: readonly VnextResource[],
   options: VnextConfigOptions,
   gateRegistry?: VnextResource,
+  projectRoot?: string,
 ): VnextConfigIssue[] {
   const issues: VnextConfigIssue[] = [];
   const entries = valuesOf(project.value, "repositories").map((candidate) => objectValue(candidate)).filter((candidate): candidate is JsonObject => Boolean(candidate));
@@ -1105,6 +1106,42 @@ function validateBundle(
   const defaultWorkflow = stringValue(project.value.defaultWorkflow) ?? "default";
   if (!workflows.has(defaultWorkflow)) issues.push(issue("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 (existsSync(writerRolePath) && implementerAgent) {
+      try {
+        const rawRole = parseRestrictedYaml(readFileSync(writerRolePath, "utf8"));
+        const roleObj = objectValue(rawRole);
+        const rosterEntries = valuesOf(roleObj ?? {}, "roster")
+          .map((candidate) => objectValue(candidate))
+          .filter((entry): entry is JsonObject => Boolean(entry));
+        const enabledRosterModels = rosterEntries
+          .filter((entry) => entry.enabled !== false)
+          .map((entry) => stringValue(entry.model))
+          .filter((m): m is string => Boolean(m));
+
+        const agentModelObj = objectValue(implementerAgent.value.model);
+        const agentModelStr = stringValue(implementerAgent.value.model);
+        const agentProvider = agentModelObj ? stringValue(agentModelObj.provider) : undefined;
+        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(issue("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 sortIssues(issues);
 }
 
@@ -1306,7 +1343,7 @@ export function loadVnextProject(projectRoot: string, options: VnextConfigOption
   }
   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) => compareCodeUnits(left.logicalPath, right.logicalPath));

package/plugins/kxm/src/vnext-engine-command.ts

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import type { VnextGateObservationInput } from "./vnext-engine-gate-records.ts";
 import type { VnextGateErrorClass, VnextGateStopCause } from "./vnext-runtime-store.ts";
 import { runtimeError } from "./vnext-runtime-store.ts";
+import { assertCommandSeatbelt } from "./safety-integrity.ts";
 
 const MAX_DIRECT_TIMER_MS = 2_147_483_647;
 export const COMMAND_TERM_GRACE_MS = 2000;
@@ -176,6 +177,7 @@ class CommandObserver implements VnextCommandObserver {
     ) {
       throw runtimeError("run_events_illegal", "command", "command timeoutMs exceeds the direct timer bound");
     }
+    assertCommandSeatbelt(this.definition.argv.join(" "));
     this.startedAt = new Date().toISOString();
     let child: ChildProcess;
     try {

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

@@ -94,6 +94,21 @@ import {
   parseRoutingRecordV2,
   behavioralConfigHash,
 } from "./routing.ts";
+import {
+  assertCommandSeatbelt,
+  DESTRUCTIVE_COMMAND_PATTERNS,
+  isRtkBypassRequired,
+  assertPinnedSshHostKeyPolicy,
+  type RtkBypassContext,
+} from "./safety-integrity.ts";
+
+export {
+  assertCommandSeatbelt,
+  DESTRUCTIVE_COMMAND_PATTERNS,
+  isRtkBypassRequired,
+  assertPinnedSshHostKeyPolicy,
+  type RtkBypassContext,
+};
 
 const trustedProducers = new WeakSet<object>();
 const CAPABILITY_PREFIX = "kxm-attempt-capability\0";
@@ -557,6 +572,7 @@ async function runPreparedCommandGate(
   definition: { readonly kind: "command"; readonly argv: readonly string[]; readonly timeoutMs: number; readonly cwd?: "control" },
   token: string,
 ): Promise<VnextRunDriveResult> {
+  assertCommandSeatbelt(definition.argv.join(" "));
   const storePath = context.eventStore.path;
   const observer = createCommandObserver({
     definition,

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

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