@kontextmind/kxm 0.6.0 → 0.7.10

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

@@ -1,4 +1,7 @@
 import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { win32 as win32Path } from "node:path";
+import { defaultSpawn } from "./vnext-oneshot-process.ts";
 
 export const DEFAULT_HARNESS = "pi";
 export type HarnessMode = "headless" | "either";
@@ -27,6 +30,7 @@ export interface OneShotParsedOutput {
   text: string;
   usage?: OneShotUsage | undefined;
   outcome?: string | undefined;
+  effectiveModel?: string | undefined;
   isError?: boolean | undefined;
   errorMessage?: string | undefined;
 }
@@ -35,7 +39,7 @@ export interface HarnessOneShotConfig {
   argv: readonly string[];
   promptVia: OneShotPromptVia;
   outputFormat: "json" | "text" | "stream-json" | "jsonl";
-  usageParser: (stdout: string, stderr: string) => OneShotParsedOutput;
+  usageParser: (stdout: string, stderr: string, requestedModel?: string) => OneShotParsedOutput;
 }
 
 export interface HarnessCatalogEntry {
@@ -54,10 +58,20 @@ 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;
-  runCommand?: (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult;
-  timeoutMs?: number;
+  env?: NodeJS.ProcessEnv | 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 {
@@ -73,6 +87,7 @@ export interface HarnessStatus {
   mode: HarnessMode;
   detected: boolean;
   authenticated: boolean | null;
+  authMethod?: "claude.ai" | "ChatGPT" | "api-key" | "antigravity-oauth" | undefined;
   dispatch?: HarnessDispatchStatus | undefined;
   command?: string;
   version?: string;
@@ -85,10 +100,10 @@ export interface HarnessInventory {
   harnesses: readonly HarnessStatus[];
 }
 
-const UNKNOWN_AUTH_HARNESSES = new Set(["gemini", "deepseek"]);
+const UNKNOWN_AUTH_HARNESSES = new Set(["deepseek"]);
 const GROK_LOGIN_LINE = "You are logged in with grok.com.";
 /** Tab-separated `id<TAB>label` rows from the committed `agy models` probe. */
-const AGY_MODEL_ROW = /^[a-z0-9][a-z0-9.+_-]*\t+\S/im;
+const AGY_MODEL_ROW = /^[a-z0-9]+(?:[._-][a-z0-9]+)+\s+\S/im;
 const CODEX_CHATGPT_LINE = "Logged in using ChatGPT";
 const CODEX_API_KEY_PREFIX = "Logged in using an API key";
 const CODEX_NEGATIVE_LINE = "Not logged in";
@@ -99,7 +114,6 @@ export const NATIVE_HARNESS_PROVIDERS: Readonly<Record<string, string>> = Object
   codex: "openai",
   grok: "xai",
   agy: "google",
-  gemini: "google",
   kimi: "moonshot",
   deepseek: "deepseek",
 });
@@ -143,7 +157,11 @@ export interface HarnessUpdateStep {
   detail?: string;
 }
 
-export function parseClaudeOneShotUsage(stdout: string, stderr: string): OneShotParsedOutput {
+function reportedModelId(value: unknown): string | undefined {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9._:/-]{0,199}$/i.test(value) ? value : undefined;
+}
+
+export function parseClaudeOneShotUsage(stdout: string, stderr: string, requestedModel?: string): OneShotParsedOutput {
   const trimmed = stdout.trim();
   if (!trimmed) {
     return {
@@ -155,26 +173,28 @@ export function parseClaudeOneShotUsage(stdout: string, stderr: string): OneShot
   try {
     const payload = JSON.parse(trimmed) as Record<string, unknown>;
     const usage = (payload.usage as Record<string, unknown> | undefined) ?? {};
-    let modelUsageDetail: Record<string, unknown> | undefined;
-    if (payload.modelUsage && typeof payload.modelUsage === "object") {
-      const values = Object.values(payload.modelUsage as Record<string, unknown>);
-      if (values.length > 0 && values[0] && typeof values[0] === "object") {
-        modelUsageDetail = values[0] as Record<string, unknown>;
-      }
-    }
-    const tokensIn = (typeof modelUsageDetail?.inputTokens === "number" ? modelUsageDetail.inputTokens : undefined)
-      ?? (typeof usage.input_tokens === "number" ? usage.input_tokens : null);
-    const tokensOut = (typeof modelUsageDetail?.outputTokens === "number" ? modelUsageDetail.outputTokens : undefined)
-      ?? (typeof usage.output_tokens === "number" ? usage.output_tokens : null);
-    const cacheReadTokens = (typeof modelUsageDetail?.cacheReadInputTokens === "number" ? modelUsageDetail.cacheReadInputTokens : undefined)
-      ?? (typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : null);
-    const cacheWriteTokens = (typeof modelUsageDetail?.cacheCreationInputTokens === "number" ? modelUsageDetail.cacheCreationInputTokens : undefined)
-      ?? (typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : null);
+    const entries = payload.modelUsage && typeof payload.modelUsage === "object" && !Array.isArray(payload.modelUsage)
+      ? Object.entries(payload.modelUsage as Record<string, unknown>).filter(([, value]) => value && typeof value === "object") : [];
+    const matches = entries.filter(([model]) => model === requestedModel
+      || (requestedModel && (model.startsWith(`${requestedModel}-`) || model.startsWith(`claude-${requestedModel}-`))));
+    const selected = matches.length === 1 ? matches[0] : entries.length === 1 ? entries[0] : undefined;
+    const modelUsageDetail = selected?.[1] as Record<string, unknown> | undefined;
+    const effectiveModel = reportedModelId(payload.model) ?? reportedModelId(selected?.[0]);
+    // Top-level usage is the attempt total; an auxiliary model is not the task's model.
+    const tokensIn = (typeof usage.input_tokens === "number" ? usage.input_tokens : undefined)
+      ?? (typeof modelUsageDetail?.inputTokens === "number" ? modelUsageDetail.inputTokens : null);
+    const tokensOut = (typeof usage.output_tokens === "number" ? usage.output_tokens : undefined)
+      ?? (typeof modelUsageDetail?.outputTokens === "number" ? modelUsageDetail.outputTokens : null);
+    const cacheReadTokens = (typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : undefined)
+      ?? (typeof modelUsageDetail?.cacheReadInputTokens === "number" ? modelUsageDetail.cacheReadInputTokens : null);
+    const cacheWriteTokens = (typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : undefined)
+      ?? (typeof modelUsageDetail?.cacheCreationInputTokens === "number" ? modelUsageDetail.cacheCreationInputTokens : null);
     const costUsd = typeof payload.total_cost_usd === "number"
       ? payload.total_cost_usd
       : (typeof modelUsageDetail?.costUSD === "number" ? modelUsageDetail.costUSD : null);
 
-    const isError = Boolean(payload.is_error || payload.error);
+    const isError = Boolean(payload.is_error || payload.error
+      || ["error", "aborted", "failed", "max_tokens", "length"].includes(String(payload.stopReason ?? payload.stop_reason ?? "")));
     const text = typeof payload.result === "string" ? payload.result : (typeof payload.text === "string" ? payload.text : "");
     const errorMessage = isError
       ? (typeof payload.error === "string"
@@ -186,6 +206,7 @@ export function parseClaudeOneShotUsage(stdout: string, stderr: string): OneShot
 
     return {
       text,
+      effectiveModel,
       isError,
       errorMessage,
       usage: {
@@ -193,18 +214,25 @@ export function parseClaudeOneShotUsage(stdout: string, stderr: string): OneShot
         tokensOut,
         cacheReadTokens,
         cacheWriteTokens,
-        contextTokens: tokensIn,
+        contextTokens: null,
         costUsd,
       },
     };
   } catch {
     return {
       text: trimmed,
+      isError: true,
+      errorMessage: "invalid Claude JSON response",
       usage: {},
     };
   }
 }
 
+/** Grok's observed one-shot JSON uses the same usage/modelUsage envelope. */
+export function parseGrokOneShotUsage(stdout: string, stderr: string, requestedModel?: string): OneShotParsedOutput {
+  return parseClaudeOneShotUsage(stdout, stderr, requestedModel);
+}
+
 export function parseCodexOneShotUsage(stdout: string, stderr: string): OneShotParsedOutput {
   const lines = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
   if (lines.length === 0) {
@@ -238,7 +266,7 @@ export function parseCodexOneShotUsage(stdout: string, stderr: string): OneShotP
           ? ((ev.error as Record<string, unknown>).message as string)
           : "turn_failed");
     }
-    if (ev.item && typeof ev.item === "object" && (ev.item as Record<string, unknown>).type === "agent_message") {
+    if (ev.type === "item.completed" && ev.item && typeof ev.item === "object" && (ev.item as Record<string, unknown>).type === "agent_message") {
       const t = (ev.item as Record<string, unknown>).text;
       if (typeof t === "string") messageTexts.push(t);
     }
@@ -247,7 +275,8 @@ export function parseCodexOneShotUsage(stdout: string, stderr: string): OneShotP
     }
   }
 
-  const text = messageTexts.join("\n").trim();
+  const text = (messageTexts.at(-1) ?? "").trim();
+  if (!events.some((event) => event.type === "turn.completed") || !text) hasError = true;
   const tokensIn = typeof usage?.input_tokens === "number" ? usage.input_tokens : null;
   const tokensOut = typeof usage?.output_tokens === "number" ? usage.output_tokens : null;
   const cacheReadTokens = typeof usage?.cached_input_tokens === "number" ? usage.cached_input_tokens : null;
@@ -262,7 +291,7 @@ export function parseCodexOneShotUsage(stdout: string, stderr: string): OneShotP
       tokensOut,
       cacheReadTokens,
       cacheWriteTokens,
-      contextTokens: tokensIn,
+      contextTokens: null,
       costUsd: null,
     },
   };
@@ -279,7 +308,15 @@ export function parseGenericOneShotUsage(stdout: string, _stderr: string): OneSh
         : (typeof rec.text === "string"
           ? rec.text
           : (typeof rec.response === "string" ? rec.response : trimmed));
-      return { text, usage: {} };
+      const u = rec.usage && typeof rec.usage === "object" ? rec.usage as Record<string, unknown> : {};
+      return { text, effectiveModel: reportedModelId(rec.model), isError: Boolean(rec.is_error || rec.error || rec.success === false), usage: {
+        tokensIn: typeof u.input_tokens === "number" ? u.input_tokens : null,
+        tokensOut: typeof u.output_tokens === "number" ? u.output_tokens : null,
+        cacheReadTokens: typeof u.cache_read_input_tokens === "number" ? u.cache_read_input_tokens : null,
+        cacheWriteTokens: typeof u.cache_creation_input_tokens === "number" ? u.cache_creation_input_tokens : null,
+        contextTokens: null,
+        costUsd: typeof rec.total_cost_usd === "number" ? rec.total_cost_usd : null,
+      } };
     }
   } catch {
     // not json
@@ -381,6 +418,18 @@ export function parseAgyOneShotUsage(stdout: string, _stderr: string): OneShotPa
 }
 
 /** Built-in harnesses. Unknown ids fail closed. Model lists live in `.kxm/models/*.yaml`, not here. */
+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 {
+  return Object.hasOwn(READ_ONLY_ONESHOT_ARGS, harness) ? READ_ONLY_ONESHOT_ARGS[harness as keyof typeof READ_ONLY_ONESHOT_ARGS] : undefined;
+}
+
 export const BUILTIN_HARNESSES: readonly HarnessCatalogEntry[] = Object.freeze([
   {
     id: "pi",
@@ -414,7 +463,7 @@ export const BUILTIN_HARNESSES: readonly HarnessCatalogEntry[] = Object.freeze([
       extensions: ["plugin", "update", "kxm", "-y"],
     },
     oneShot: {
-      argv: ["-p", "--output-format", "json"],
+      argv: ["-p", ...oneShotReadOnlyArgs("claude")!, "--output-format", "json"],
       promptVia: "stdin",
       outputFormat: "json",
       usageParser: parseClaudeOneShotUsage,
@@ -430,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,
@@ -446,21 +495,12 @@ export const BUILTIN_HARNESSES: readonly HarnessCatalogEntry[] = Object.freeze([
     authArgs: ["login", "status"],
     update: { self: ["update"] },
     oneShot: {
-      argv: ["exec", "--json", "-"],
+      argv: ["exec", ...oneShotReadOnlyArgs("codex")!, "--json", "-"],
       promptVia: "stdin",
       outputFormat: "json",
       usageParser: parseCodexOneShotUsage,
     },
   },
-  {
-    id: "gemini",
-    label: "Gemini CLI",
-    default: false,
-    mode: "either",
-    commands: ["gemini"],
-    versionArgs: ["--version"],
-    update: { self: ["update"] },
-  },
   {
     id: "deepseek",
     label: "DeepSeek",
@@ -486,10 +526,10 @@ export const BUILTIN_HARNESSES: readonly HarnessCatalogEntry[] = Object.freeze([
     authArgs: ["models"],
     update: { self: ["update"] },
     oneShot: {
-      argv: ["--output-format", "json"],
-      promptVia: "stdin",
+      argv: [...oneShotReadOnlyArgs("grok")!, "--output-format", "json", "--single"],
+      promptVia: "arg",
       outputFormat: "json",
-      usageParser: parseClaudeOneShotUsage,
+      usageParser: parseGrokOneShotUsage,
     },
   },
   {
@@ -502,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,
@@ -518,7 +558,55 @@ export function isKnownHarnessId(id: string, extra: Iterable<string> = []): bool
   return false;
 }
 
-function defaultRunner(env: NodeJS.ProcessEnv): (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult {
+/** Bare catalog command ids only; never a path or shell metacharacter. */
+export const SAFE_HARNESS_COMMAND_ID = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
+export function harnessCommandCandidates(
+  command: string,
+  platform: NodeJS.Platform = process.platform,
+): readonly string[] {
+  if (platform !== "win32" || !SAFE_HARNESS_COMMAND_ID.test(command)) return [command];
+  return [command, `${command}.exe`, `${command}.cmd`];
+}
+
+export function isWindowsHarnessShim(command: string): boolean {
+  return /\.(cmd|bat)$/i.test(command.replace(/\\/g, "/").split("/").pop() ?? command);
+}
+
+/** Shell only for allowlisted `name.cmd` on win32. Bare ids stay spawn-without-shell. */
+export function harnessSpawnUsesShell(command: string, platform: NodeJS.Platform = process.platform): boolean {
+  if (platform !== "win32") return false;
+  const base = command.replace(/\\/g, "/").split("/").pop() ?? "";
+  return /^[A-Za-z][A-Za-z0-9_-]*\.cmd$/i.test(base);
+}
+
+/** Allowlisted npm-global inner `.exe`, relative to the directory that contains `name.cmd`. */
+export const WIN_NPM_INNER_EXE: Readonly<Record<string, readonly string[]>> = Object.freeze({
+  claude: Object.freeze(["node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe"]),
+});
+
+export function findWinNpmInnerExe(
+  cliId: string,
+  options: {
+    platform?: NodeJS.Platform | undefined;
+    pathEnv?: string | undefined;
+    existsSync?: ((path: string) => boolean) | undefined;
+  } = {},
+): string | undefined {
+  if ((options.platform ?? process.platform) !== "win32") return undefined;
+  const segments = WIN_NPM_INNER_EXE[cliId];
+  if (!segments) return undefined;
+  const exists = options.existsSync ?? existsSync;
+  const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
+  for (const dir of pathEnv.split(";").filter(Boolean)) {
+    if (!exists(win32Path.join(dir, `${cliId}.cmd`))) continue;
+    const inner = win32Path.join(dir, ...segments);
+    if (exists(inner)) return inner;
+  }
+  return undefined;
+}
+
+function defaultRunner(env: NodeJS.ProcessEnv): HarnessRunCommand {
   return (command, args, timeoutMs) => {
     try {
       const result = spawnSync(command, [...args], {
@@ -526,6 +614,7 @@ function defaultRunner(env: NodeJS.ProcessEnv): (command: string, args: readonly
         timeout: timeoutMs,
         windowsHide: true,
         env,
+        shell: harnessSpawnUsesShell(command),
       });
       if (result.error) {
         const code = (result.error as NodeJS.ErrnoException).code;
@@ -543,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;
@@ -588,7 +708,7 @@ function isCodexApiKeyLine(line: string): boolean {
   return line === CODEX_API_KEY_PREFIX || line.startsWith(`${CODEX_API_KEY_PREFIX} - `);
 }
 
-function interpretAuth(id: string, result: HarnessCommandResult): { authenticated: boolean | null; issues: string[] } {
+function interpretAuth(id: string, result: HarnessCommandResult): Pick<HarnessStatus, "authenticated" | "authMethod"> & { issues: string[] } {
   const conflict = authConflictIssue(result);
   if (conflict) return { authenticated: null, issues: [conflict] };
   if (result.error) return { authenticated: null, issues: ["auth_probe_error"] };
@@ -597,7 +717,10 @@ function interpretAuth(id: string, result: HarnessCommandResult): { authenticate
   if (id === "claude") {
     const payload = parseJsonObject(result.stdout);
     if (payload && payload.loggedIn === false) return { authenticated: false, issues: ["not_authenticated"] };
-    if (commandSucceeded(result) && payload && payload.loggedIn === true) return { authenticated: true, issues: [] };
+    if (commandSucceeded(result) && payload && payload.loggedIn === true) return {
+      authenticated: true, issues: [],
+      ...(payload.authMethod === "claude.ai" || payload.authMethod === "api-key" ? { authMethod: payload.authMethod } : {}),
+    };
     return { authenticated: null, issues: ["auth_unparsed"] };
   }
   if (id === "codex") {
@@ -605,10 +728,10 @@ function interpretAuth(id: string, result: HarnessCommandResult): { authenticate
       return { authenticated: false, issues: ["not_authenticated"] };
     }
     if (commandSucceeded(result) && lines.some((line) => line === CODEX_CHATGPT_LINE)) {
-      return { authenticated: true, issues: [] };
+      return { authenticated: true, authMethod: "ChatGPT", issues: [] };
     }
     if (commandSucceeded(result) && lines.some((line) => isCodexApiKeyLine(line))) {
-      return { authenticated: true, issues: ["auth_api_key"] };
+      return { authenticated: true, authMethod: "api-key", issues: ["auth_api_key"] };
     }
     return { authenticated: null, issues: ["auth_unparsed"] };
   }
@@ -621,7 +744,7 @@ function interpretAuth(id: string, result: HarnessCommandResult): { authenticate
     if (!commandSucceeded(result) || !text.trim()) {
       return { authenticated: false, issues: ["not_authenticated"] };
     }
-    if (AGY_MODEL_ROW.test(text)) return { authenticated: true, issues: [] };
+    if (AGY_MODEL_ROW.test(text)) return { authenticated: true, authMethod: "antigravity-oauth", issues: [] };
     return { authenticated: null, issues: ["auth_unparsed"] };
   }
   if (id === "kimi") {
@@ -652,37 +775,81 @@ export function resolveDispatchStatus(
     return {
       status: "no",
       supported: false,
-      reason: entry.id === "gemini" ? "deprecated_client" : "no_headless_mode",
+      reason: "no_headless_mode",
     };
   }
+  if (entry.id !== "pi" && !oneShotReadOnlyArgs(entry.id)) {
+    return { status: "no", supported: false, reason: "permission_profile_unaudited" };
+  }
   if (authenticated === false) {
     return { status: "no", supported: false, reason: "not_authenticated" };
   }
   if (authenticated === null) {
-    return { status: "no", supported: false, reason: issues[0] ?? "auth_unknown" };
+    const authIssue = issues.find((issue) => issue === "auth_context_required" || issue === "auth_unknown" || issue === "auth_unparsed" || issue.startsWith("auth_"));
+    return { status: "no", supported: false, reason: authIssue ?? issues[0] ?? "auth_unknown" };
   }
   return { status: "yes", supported: true };
 }
 
+function tryHarnessCommand(
+  candidate: string,
+  entry: HarnessCatalogEntry,
+  runCommand: (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult,
+  timeoutMs: number,
+): { command: string; version: string | undefined } | undefined {
+  const result = runCommand(candidate, entry.versionArgs, timeoutMs);
+  if (result.error === "ENOENT") return undefined;
+  if (result.error && result.code === null && !result.stdout && !result.stderr) return undefined;
+  return {
+    command: candidate,
+    version: firstLine(result.stdout) ?? firstLine(result.stderr),
+  };
+}
+
+function detectHarnessCommand(
+  entry: HarnessCatalogEntry,
+  runCommand: (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult,
+  timeoutMs: number,
+  platform: NodeJS.Platform,
+  probe: Pick<HarnessProbeOptions, "env" | "existsSync"> = {},
+): { command: string; version: string | undefined } | undefined {
+  const candidates = entry.commands.flatMap((base) => [...harnessCommandCandidates(base, platform)]);
+  for (const candidate of candidates) {
+    if (isWindowsHarnessShim(candidate)) continue;
+    const found = tryHarnessCommand(candidate, entry, runCommand, timeoutMs);
+    if (found) return found;
+  }
+  const inner = findWinNpmInnerExe(entry.id, {
+    platform,
+    pathEnv: probe.env?.PATH ?? process.env.PATH ?? "",
+    existsSync: probe.existsSync,
+  });
+  if (inner) {
+    const found = tryHarnessCommand(inner, entry, runCommand, timeoutMs);
+    if (found) return found;
+  }
+  for (const candidate of candidates) {
+    if (!isWindowsHarnessShim(candidate)) continue;
+    const found = tryHarnessCommand(candidate, entry, runCommand, timeoutMs);
+    if (found) return found;
+  }
+  return undefined;
+}
+
 function probeEntry(
   entry: HarnessCatalogEntry,
   runCommand: (command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult,
   timeoutMs: number,
+  platform: NodeJS.Platform,
+  probe: Pick<HarnessProbeOptions, "env" | "existsSync"> = {},
 ): HarnessStatus {
   const issues: string[] = [];
-  let detected = false;
-  let command: string | undefined;
-  let version: string | undefined;
-  for (const candidate of entry.commands) {
-    const result = runCommand(candidate, entry.versionArgs, timeoutMs);
-    if (result.error === "ENOENT") continue;
-    if (result.error && result.code === null && !result.stdout && !result.stderr) continue;
-    detected = true;
-    command = candidate;
-    version = firstLine(result.stdout) ?? firstLine(result.stderr);
-    break;
-  }
+  const found = detectHarnessCommand(entry, runCommand, timeoutMs, platform, probe);
+  const detected = Boolean(found);
+  const command = found?.command;
+  const version = found?.version;
   let authenticated: boolean | null = null;
+  let authMethod: HarnessStatus["authMethod"];
   if (!detected) authenticated = false;
   else if (entry.id === "pi") {
     authenticated = null;
@@ -691,10 +858,14 @@ function probeEntry(
     authenticated = null;
     if (UNKNOWN_AUTH_HARNESSES.has(entry.id)) issues.push("auth_unknown");
   } else if (command) {
-    const parsed = interpretAuth(entry.id, runCommand(command, entry.authArgs, timeoutMs));
+    // Auth CLIs may initialize hooks/OAuth state and exceed the short binary-detection timeout.
+    // Keep detection bounded while allowing the documented auth probe to complete.
+    const parsed = interpretAuth(entry.id, runCommand(command, entry.authArgs, Math.max(timeoutMs, 10_000)));
     authenticated = parsed.authenticated;
+    authMethod = parsed.authMethod;
     issues.push(...parsed.issues);
   }
+  if (command && isWindowsHarnessShim(command)) issues.push("windows_shim");
   const dispatch = resolveDispatchStatus(entry, detected, authenticated, issues);
   return {
     id: entry.id,
@@ -703,6 +874,7 @@ function probeEntry(
     mode: entry.mode,
     detected,
     authenticated,
+    ...(authMethod ? { authMethod } : {}),
     dispatch,
     ...(command ? { command } : {}),
     ...(version ? { version } : {}),
@@ -718,15 +890,28 @@ function probeEntry(
 export function probeHarnesses(options: HarnessProbeOptions = {}): HarnessInventory {
   const timeoutMs = options.timeoutMs ?? 3000;
   const runCommand = options.runCommand ?? defaultRunner(options.env ?? process.env);
+  const platform = options.platform ?? process.platform;
   return {
     defaultHarness: DEFAULT_HARNESS,
-    harnesses: BUILTIN_HARNESSES.map((entry) => probeEntry(entry, runCommand, timeoutMs)),
+    harnesses: BUILTIN_HARNESSES.map((entry) => probeEntry(entry, runCommand, timeoutMs, platform, options)),
   };
 }
 
+/**
+ * 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.detected && entry.authenticated === true)
+    .filter((entry) => entry !== undefined && entry.detected && entry.authenticated === true)
     .map((entry) => entry.id);
   if (eligible.length === 0) throw new Error("no_authenticated_harness");
   return eligible;
@@ -785,7 +970,7 @@ export function validateHarnessModelPair(
     return { valid: true };
   }
 
-  if (harnessId === "agy" || harnessId === "gemini") {
+  if (harnessId === "agy") {
     if (provider && provider !== "google") {
       return { valid: false, issue: "harness_unhosted_model", message: `harness ${harnessId} does not host provider ${provider}` };
     }
@@ -799,7 +984,7 @@ export function validateHarnessModelPair(
     if (provider && provider !== "moonshot") {
       return { valid: false, issue: "harness_unhosted_model", message: `harness kimi does not host provider ${provider}` };
     }
-    if (model && !/^(kimi|moonshot)-/i.test(model)) {
+    if (model && !/^(kimi|moonshot)(?:-|$)/i.test(model) && !/^kimi-for-coding(?:-|$)/i.test(model)) {
       return { valid: false, issue: "harness_unhosted_model", message: `harness kimi only hosts kimi/moonshot models, received ${model}` };
     }
     return { valid: true };
@@ -843,11 +1028,14 @@ export interface HarnessAssignmentProbeOptions {
   env?: NodeJS.ProcessEnv | undefined;
   runCommand?: ((command: string, args: readonly string[], timeoutMs: number) => HarnessCommandResult) | undefined;
   timeoutMs?: number | undefined;
+  platform?: NodeJS.Platform | undefined;
+  existsSync?: ((path: string) => boolean) | undefined;
 }
 
 export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions): HarnessStatus {
   const timeoutMs = options.timeoutMs ?? 3000;
   const runCommand = options.runCommand ?? defaultRunner(options.env ?? process.env);
+  const platform = options.platform ?? process.platform;
   const entry = BUILTIN_HARNESSES.find((candidate) => candidate.id === options.harness);
   if (!entry) {
     return {
@@ -884,18 +1072,11 @@ export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions):
     }
   }
 
-  let detected = false;
-  let command: string | undefined;
-  let version: string | undefined;
-  for (const candidate of entry.commands) {
-    const result = runCommand(candidate, entry.versionArgs, timeoutMs);
-    if (result.error === "ENOENT") continue;
-    if (result.error && result.code === null && !result.stdout && !result.stderr) continue;
-    detected = true;
-    command = candidate;
-    version = firstLine(result.stdout) ?? firstLine(result.stderr);
-    break;
-  }
+  const found = detectHarnessCommand(entry, runCommand, timeoutMs, platform, options);
+  const detected = Boolean(found);
+  const command = found?.command;
+  const version = found?.version;
+  const shimIssue = command && isWindowsHarnessShim(command) ? ["windows_shim"] : [];
 
   if (!detected || !command) {
     return {
@@ -932,7 +1113,7 @@ export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions):
           extensions: Boolean(entry.update.extensions?.length),
           models: Boolean(entry.update.models?.length),
         },
-        issues: ["auth_context_required"],
+        issues: ["auth_context_required", ...shimIssue],
       };
     }
 
@@ -960,6 +1141,7 @@ export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions):
       authenticated = false;
       issues.push("not_authenticated");
     }
+    issues.push(...shimIssue);
 
     const dispatch = resolveDispatchStatus(entry, true, authenticated, issues);
 
@@ -982,7 +1164,62 @@ export function probeHarnessAssignment(options: HarnessAssignmentProbeOptions):
     };
   }
 
-  return probeEntry(entry, runCommand, timeoutMs);
+  return probeEntry(entry, runCommand, timeoutMs, platform);
+}
+
+export interface AsyncHarnessAssignmentProbeOptions extends Omit<HarnessAssignmentProbeOptions, "runCommand"> {
+  signal?: AbortSignal | undefined;
+  runCommand?: HarnessRunCommandAsync | undefined;
+}
+
+class PendingHarnessCommand {
+  command: string;
+  args: readonly string[];
+  timeoutMs: number;
+  key: string;
+  constructor(command: string, args: readonly string[], timeoutMs: number, key: string) {
+    this.command = command;
+    this.args = [...args];
+    this.timeoutMs = timeoutMs;
+    this.key = key;
+  }
+}
+
+async function replayHarnessProbe<T>(
+  run: HarnessRunCommandAsync,
+  execute: (runCommand: HarnessRunCommand) => T,
+  limit: number,
+): Promise<T> {
+  const observed = new Map<string, HarnessCommandResult>();
+  for (let commands = 0; commands <= limit; commands++) {
+    try {
+      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 === 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(
@@ -991,6 +1228,7 @@ export function probeHarnessesForModel(
 ): HarnessInventory {
   const timeoutMs = options.timeoutMs ?? 3000;
   const runCommand = options.runCommand ?? defaultRunner(options.env ?? process.env);
+  const platform = options.platform ?? process.platform;
   return {
     defaultHarness: DEFAULT_HARNESS,
     harnesses: BUILTIN_HARNESSES.map((entry) =>
@@ -1000,11 +1238,25 @@ export function probeHarnessesForModel(
         model: modelSpec.model,
         runCommand,
         timeoutMs,
+        platform,
+        env: options.env,
+        existsSync: options.existsSync,
       })
     ),
   };
 }
 
+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"] : [];