@kyo-so/cli 0.13.1 → 0.14.0

package/dist/bin/kyoso.js

@@ -183951,7 +183951,7 @@ var JUDGE_MAX_OUTPUT_TOKENS = 4096;
 var RAW_OUTPUT_MAX_CHARS = 16384;
 var TRACE_DIR = ".kyoso/traces";
 var KYOSO_CHILD_AGENT = "KYOSO_CHILD_AGENT";
-var KYOSO_VERSION = "0.13.1";
+var KYOSO_VERSION = "0.14.0";
 
 // src/utils/pathContainment.ts
 import { resolve, sep as sep2 } from "node:path";
@@ -187092,13 +187092,14 @@ function isPlainObject2(value) {
 import { spawnSync } from "node:child_process";
 
 // src/cli/pluginRuntimeContract.ts
-var PLUGIN_RUNTIME_COMPATIBILITY_SCHEMA_VERSION = 1;
+var PLUGIN_RUNTIME_COMPATIBILITY_SCHEMA_VERSION = 2;
 var MINIMUM_SUPPORTED_CODEX_VERSION = "0.144.0-alpha.4";
 var PLUGIN_RUNTIME_EXPECTED_CONTRACT = {
   distribution: {
-    pluginVersion: "0.7.0",
+    pluginVersion: "0.7.2",
     mcpCommand: "npx",
-    mcpPackagePin: "@kyo-so/cli@0.13.0"
+    mcpPackagePin: "@kyo-so/cli@0.13.1",
+    mcpExecutable: "kyoso"
   },
   marketplace: {
     name: "kyoso",
@@ -187501,21 +187502,66 @@ import {
   relative,
   resolve as resolve5
 } from "node:path";
+
+// src/cli/packageRunner.ts
+var KYOSO_PACKAGE_NAME = "@kyo-so/cli";
+var KYOSO_EXECUTABLE_NAME = "kyoso";
+var COMPLETE_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function buildKyosoPackageCommand(options) {
+  const packageSpec = options.version === undefined ? KYOSO_PACKAGE_NAME : `${KYOSO_PACKAGE_NAME}@${assertCompleteSemVer(options.version)}`;
+  const cliArgs = [...options.cliArgs];
+  if (options.runner === "npx") {
+    return {
+      command: "npx",
+      args: [
+        "-y",
+        `--package=${packageSpec}`,
+        KYOSO_EXECUTABLE_NAME,
+        ...cliArgs
+      ]
+    };
+  }
+  return {
+    command: "bunx",
+    args: ["--package", packageSpec, KYOSO_EXECUTABLE_NAME, ...cliArgs]
+  };
+}
+function formatKyosoPackageCommand(options) {
+  const command = buildKyosoPackageCommand(options);
+  return [command.command, ...command.args].join(" ");
+}
+function isCompleteSemVer(value) {
+  const match = COMPLETE_SEMVER.exec(value);
+  const prerelease = match?.[4];
+  return match !== null && (prerelease === undefined || prerelease.split(".").every((identifier) => {
+    return !/^\d+$/.test(identifier) || identifier === "0" || !identifier.startsWith("0");
+  }));
+}
+function assertCompleteSemVer(value) {
+  if (isCompleteSemVer(value))
+    return value;
+  throw new Error(`Kyoso package version must be a complete SemVer; received ${JSON.stringify(value)}.`);
+}
+
+// src/cli/integration.ts
 function detectCli(options) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
   return {
     kyoso: detectInstalledKyoso(options.cwd, env, platform),
-    npx: commandExists("npx", env, platform),
-    bunx: commandExists("bunx", env, platform)
+    npx: commandExists("npx", env, platform) ? "available" : "missing",
+    bunx: commandExists("bunx", env, platform) ? "present-unverified" : "missing"
   };
 }
 function determineNonPluginIntegration(options) {
-  const warnings = manualMcpWarnings(options.manualMcpStatus);
+  const warnings = manualMcpWarnings(options.manualMcpStatus, options.manualMcpRegistrations, options.cli);
   if (options.manualMcpStatus === "unknown") {
     return { mode: "unknown", warnings };
   }
   if (options.manualMcpStatus === "enabled") {
+    if (!hasCurrentManualMcp(options.manualMcpRegistrations, options.cli)) {
+      return { mode: "unknown", warnings };
+    }
     return {
       mode: options.hasSkill ? "manual-mcp" : "mcp-only",
       warnings
@@ -187527,10 +187573,13 @@ function determineNonPluginIntegration(options) {
     if (options.cli.kyoso.kind === "installed") {
       return { mode: "cli-skill", warnings };
     }
-    if (options.cli.npx || options.cli.bunx) {
+    if (options.cli.npx === "available") {
       warnings.push("Package-runner fallback may require network access and can drift between versions.");
       return { mode: "skill-on-demand", warnings };
     }
+    if (options.cli.bunx === "present-unverified") {
+      warnings.push("bunx is present but unverified; install Kyoso on PATH or npx first, then run the client-specific setup with --write --runner bunx to verify Bun 1.3.14 or newer.");
+    }
     if (options.cli.kyoso.kind === "unknown") {
       return { mode: "unknown", warnings };
     }
@@ -187545,6 +187594,13 @@ function determineNonPluginIntegration(options) {
   }
   return { mode: "missing", warnings };
 }
+function formatRunnerAvailability(runner) {
+  if (runner === "available")
+    return "available";
+  if (runner === "present-unverified")
+    return "present-unverified";
+  return "missing";
+}
 function formatCliAvailability(cli) {
   if (cli.kind === "installed") {
     return `installed @kyo-so/cli ${cli.version} (${cli.scope})`;
@@ -187609,7 +187665,9 @@ function realPathOrResolved(path) {
     return resolve5(path);
   }
 }
-function manualMcpWarnings(status) {
+function manualMcpWarnings(status, registrations, cli) {
+  if (status === "missing")
+    return [];
   if (status === "disabled")
     return ["Manual MCP registration is disabled."];
   if (status === "unknown") {
@@ -187617,8 +187675,89 @@ function manualMcpWarnings(status) {
       "Manual MCP registration could not be safely classified from its configuration."
     ];
   }
+  if (registrations.length === 0) {
+    return [
+      "Manual MCP registration is enabled but no exact registration could be verified."
+    ];
+  }
+  if (registrations.length !== 1) {
+    return [
+      "Multiple manual MCP registrations were found; their effective precedence is not inferred."
+    ];
+  }
+  const registration = registrations[0];
+  const invocation = registration?.invocation;
+  if (invocation?.kind === "legacy") {
+    return [legacyManualMcpRepairWarning(registration, cli)];
+  }
+  if (invocation?.kind === "custom") {
+    return [
+      "Manual MCP registration is custom/unverified and was not treated as a ready Kyoso registration."
+    ];
+  }
+  if (invocation?.kind === "unknown") {
+    return [
+      "Manual MCP invocation could not be safely classified and was not treated as a ready Kyoso registration."
+    ];
+  }
+  if (invocation?.runner === "npx" && cli.npx !== "available") {
+    return [
+      "Manual MCP registration uses npx, but npx is not available on PATH."
+    ];
+  }
+  if (invocation?.runner === "bunx") {
+    if (cli.bunx === "missing") {
+      return [
+        "Manual MCP registration uses bunx, but bunx is not available on PATH."
+      ];
+    }
+    const verificationCommand = registration ? manualMcpSetupCommand(registration, cli, [
+      "--write",
+      "--runner",
+      "bunx"
+    ]) : undefined;
+    return [
+      `Manual MCP registration uses bunx, but normal doctor does not verify the required Bun capability.${verificationCommand ? ` Run \`${verificationCommand}\` before treating it as ready.` : " Run setup with --write --runner bunx from an installed Kyoso CLI before treating it as ready."}`
+    ];
+  }
   return [];
 }
+function legacyManualMcpRepairWarning(registration, cli) {
+  if (!registration) {
+    return "Manual MCP registration uses legacy package-runner arguments and requires repair.";
+  }
+  const client = registration.scope === "codex-global" ? "codex" : registration.scope === "claude-project" ? "claude-code" : undefined;
+  if (!client) {
+    return `Manual MCP registration at ${registration.path} uses legacy package-runner arguments. Its ${registration.scope} scope is not automatically migrated; update it manually.`;
+  }
+  const runner = cli.npx === "available" ? "npx" : cli.kyoso.kind === "installed" && cli.bunx === "present-unverified" ? "bunx" : undefined;
+  const command = runner ? manualMcpSetupCommand(registration, cli, [
+    "--write",
+    "--runner",
+    runner,
+    "--force"
+  ]) : undefined;
+  if (!command) {
+    return `Manual MCP registration at ${registration.path} uses legacy package-runner arguments, but no executable Kyoso repair path is available. Update it manually.`;
+  }
+  return `Manual MCP registration uses legacy package-runner arguments. Run \`${command}\` to migrate this exact registration.`;
+}
+function manualMcpSetupCommand(registration, cli, setupArgs) {
+  const client = registration.scope === "codex-global" ? "codex" : registration.scope === "claude-project" ? "claude-code" : undefined;
+  if (!client)
+    return;
+  const cliArgs = ["setup", client, ...setupArgs];
+  if (cli.kyoso.kind === "installed") {
+    return `kyoso ${cliArgs.join(" ")}`;
+  }
+  if (cli.npx !== "available")
+    return;
+  return formatKyosoPackageCommand({ runner: "npx", cliArgs });
+}
+function hasCurrentManualMcp(registrations, cli) {
+  const registration = registrations[0];
+  return registrations.length === 1 && registration?.invocation.kind === "current" && registration.invocation.runner === "npx" && cli.npx === "available";
+}
 function cliIdentityWarnings(cli) {
   if (cli.kind === "transient") {
     return [
@@ -187677,12 +187816,206 @@ function isRecord8(value) {
 
 // src/cli/setup.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname8, join as join6, resolve as resolve7 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  realpathSync as realpathSync2,
+  mkdtempSync,
+  rmSync
+} from "node:fs";
+import {
+  chmod,
+  lstat as lstat3,
+  mkdir as mkdir5,
+  open,
+  readFile as readFile6,
+  rename as rename2,
+  rm as rm2,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, delimiter as delimiter2, dirname as dirname8, join as join6, resolve as resolve7 } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/cli/manualMcpInvocation.ts
+var GENERATED_MCP_ENV_VALUE_NAMES = new Set([
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "OPENROUTER_API_KEY"
+]);
+var GENERATED_MCP_ENV_VAR_NAMES = new Set([
+  "OPENAI_API_KEY",
+  "CODEX_API_KEY",
+  "CODEX_HOME",
+  "CODEX_ACCESS_TOKEN",
+  "OPENROUTER_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN"
+]);
+function inspectManualMcpInvocation(value) {
+  if (!isRecord9(value)) {
+    return { kind: "unknown", reason: "MCP entry is not an object." };
+  }
+  if (typeof value.command !== "string" || value.command.length === 0) {
+    return {
+      kind: "unknown",
+      reason: "MCP command is missing or is not a string."
+    };
+  }
+  if (!Array.isArray(value.args) || !value.args.every(isString)) {
+    return {
+      kind: "unknown",
+      reason: "MCP args are missing or are not an array of strings."
+    };
+  }
+  const environment = inspectMcpEnvironment(value);
+  if (value.command === "npx") {
+    return applyEnvironmentSafety(inspectNpx(value.args), environment);
+  }
+  if (value.command === "bunx") {
+    return applyEnvironmentSafety(inspectBunx(value.args), environment);
+  }
+  return {
+    kind: "custom",
+    reason: `MCP command ${JSON.stringify(value.command)} is not a Kyoso package runner.`
+  };
+}
+function inspectMcpEnvironment(value) {
+  if ("env" in value && !isGeneratedMcpEnvironment(value.env)) {
+    return {
+      kind: "custom",
+      reason: "MCP environment is not limited to generated credential placeholders."
+    };
+  }
+  if ("env_vars" in value && !isGeneratedMcpEnvironmentVariables(value.env_vars)) {
+    return {
+      kind: "custom",
+      reason: "MCP environment variable forwarding is not limited to generated credential names."
+    };
+  }
+  return;
+}
+function applyEnvironmentSafety(invocation, environment) {
+  return environment ?? invocation;
+}
+function isGeneratedMcpEnvironment(value) {
+  if (!isRecord9(value))
+    return false;
+  return Object.entries(value).every(([name, placeholder]) => GENERATED_MCP_ENV_VALUE_NAMES.has(name) && placeholder === `\${${name}}`);
+}
+function isGeneratedMcpEnvironmentVariables(value) {
+  if (!Array.isArray(value) || !value.every(isString))
+    return false;
+  return new Set(value).size === value.length && value.every((name) => GENERATED_MCP_ENV_VAR_NAMES.has(name));
+}
+function inspectNpx(args) {
+  const current = parseNpxCurrent(args);
+  if (current) {
+    return {
+      kind: "current",
+      runner: "npx",
+      packageSpec: current.packageSpec,
+      reason: "npx explicitly selects the Kyoso executable from its package."
+    };
+  }
+  const legacy = parseNpxLegacy(args);
+  if (legacy)
+    return legacyInspection("npx", legacy, args);
+  return {
+    kind: "custom",
+    runner: "npx",
+    reason: "npx arguments do not exactly match a supported Kyoso invocation."
+  };
+}
+function inspectBunx(args) {
+  const current = parseBunxCurrent(args);
+  if (current) {
+    return {
+      kind: "current",
+      runner: "bunx",
+      packageSpec: current.packageSpec,
+      reason: "bunx explicitly selects the Kyoso executable from its package."
+    };
+  }
+  const legacy = parseBunxLegacy(args);
+  if (legacy)
+    return legacyInspection("bunx", legacy, args);
+  return {
+    kind: "custom",
+    runner: "bunx",
+    reason: "bunx arguments do not exactly match a supported Kyoso invocation."
+  };
+}
+function legacyInspection(runner, packageSpec, legacyArgs) {
+  const version2 = versionFromKnownPackageSpec(packageSpec);
+  if (version2 === undefined && packageSpec !== KYOSO_PACKAGE_NAME) {
+    return {
+      kind: "custom",
+      runner,
+      packageSpec,
+      reason: "Kyoso package spec is a tag, range, or malformed pin and is preserved."
+    };
+  }
+  return {
+    kind: "legacy",
+    runner,
+    packageSpec,
+    legacyArgs: [...legacyArgs],
+    replacement: buildKyosoPackageCommand({
+      runner,
+      ...version2 === undefined ? {} : { version: version2 },
+      cliArgs: ["mcp"]
+    }),
+    reason: "Kyoso package runner relies on executable inference with a multi-bin package."
+  };
+}
+function parseNpxCurrent(args) {
+  if (args.length !== 4 || args[0] !== "-y" || args[2] !== KYOSO_EXECUTABLE_NAME || args[3] !== "mcp") {
+    return;
+  }
+  const packageSpec = args[1]?.startsWith("--package=") ? args[1].slice("--package=".length) : undefined;
+  return packageSpec && isKnownPackageSpec(packageSpec) ? { packageSpec } : undefined;
+}
+function parseBunxCurrent(args) {
+  if (args.length !== 4 || args[0] !== "--package" || args[2] !== KYOSO_EXECUTABLE_NAME || args[3] !== "mcp") {
+    return;
+  }
+  const packageSpec = args[1];
+  return packageSpec && isKnownPackageSpec(packageSpec) ? { packageSpec } : undefined;
+}
+function parseNpxLegacy(args) {
+  const packageIndex = args[0] === "-y" ? 1 : 0;
+  if (args.length !== packageIndex + 2 || args[packageIndex + 1] !== "mcp") {
+    return;
+  }
+  const packageSpec = args[packageIndex];
+  return packageSpec && packageSpec.startsWith(KYOSO_PACKAGE_NAME) ? packageSpec : undefined;
+}
+function parseBunxLegacy(args) {
+  if (args.length !== 2 || args[1] !== "mcp")
+    return;
+  const packageSpec = args[0];
+  return packageSpec && packageSpec.startsWith(KYOSO_PACKAGE_NAME) ? packageSpec : undefined;
+}
+function isKnownPackageSpec(packageSpec) {
+  return packageSpec === KYOSO_PACKAGE_NAME || versionFromKnownPackageSpec(packageSpec) !== undefined;
+}
+function versionFromKnownPackageSpec(packageSpec) {
+  const prefix = `${KYOSO_PACKAGE_NAME}@`;
+  if (!packageSpec.startsWith(prefix))
+    return;
+  const version2 = packageSpec.slice(prefix.length);
+  return isCompleteSemVer(version2) ? version2 : undefined;
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+
 // src/cli/skillInstall.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import {
@@ -187709,8 +188042,14 @@ import {
 } from "node:path";
 
 // src/cli/knownSkillDigests.ts
-var CURRENT_SKILL_DIGEST = "sha256:8654e68ea61f2acea29027056802bf627ad737f084c9a86ab052946943538409";
+var CURRENT_SKILL_DIGEST = "sha256:d28acaadf490df9e58e12f195804f181a683d0d33344275d7989efbee26a4504";
 var KNOWN_SKILL_DIGESTS_BY_VERSION = {
+  "0.13.1": [
+    {
+      digest: "sha256:8654e68ea61f2acea29027056802bf627ad737f084c9a86ab052946943538409",
+      kind: "historical"
+    }
+  ],
   "0.11.0": [
     {
       digest: "sha256:110dd872a3d1c8a71474a0eadb226f51a6addd86f9d4f3ed17b73678b3179a4e",
@@ -188270,7 +188609,15 @@ async function runSetup(options) {
     skillOnly: options.skillOnly ?? false,
     force: options.force ?? false,
     withOpenRouter: options.withOpenRouter ?? false,
+    customCommand: options.command !== undefined,
+    runnerExplicit: options.runner !== undefined,
     mcpCommand: command,
+    bunxVersionProbe: options.bunxVersionProbe ?? probeBunxVersion,
+    beforeManualMcpWrite: options.beforeManualMcpWrite,
+    beforeManualMcpCommit: options.beforeManualMcpCommit,
+    afterManualMcpValidation: options.afterManualMcpValidation,
+    beforeManualMcpRename: options.beforeManualMcpRename,
+    manualMcpRename: options.manualMcpRename ?? rename2,
     sourceSkillDir: resolveBundledSkillDir()
   };
   if (!client)
@@ -188281,10 +188628,7 @@ async function runSetup(options) {
   return renderResults(context, await setupClaudeCode(context));
 }
 function commandForRunner(runner) {
-  if (runner === "bunx") {
-    return { command: "bunx", args: ["@kyo-so/cli", "mcp"] };
-  }
-  return { command: "npx", args: ["-y", "@kyo-so/cli", "mcp"] };
+  return buildKyosoPackageCommand({ runner, cliArgs: ["mcp"] });
 }
 function buildCodexMcpToml(command, withOpenRouter = false) {
   const envVars = [
@@ -188380,16 +188724,18 @@ function detectSetup(options) {
   ]);
   return {
     codex: {
-      mcp: codexMcp.status === "enabled",
+      mcp: isCurrentManualMcp(codexMcp),
       skill: codexSkillPaths.length > 0,
       manualMcpStatus: codexMcp.status,
+      manualMcpRegistrations: codexMcp.registrations,
       mcpPaths: codexMcp.paths,
       skillPaths: codexSkillPaths
     },
     "claude-code": {
-      mcp: claudeMcp.status === "enabled",
+      mcp: isCurrentManualMcp(claudeMcp),
       skill: claudeSkillPaths.length > 0,
       manualMcpStatus: claudeMcp.status,
+      manualMcpRegistrations: claudeMcp.registrations,
       mcpPaths: claudeMcp.paths,
       skillPaths: claudeSkillPaths
     }
@@ -188425,14 +188771,19 @@ async function ensureCodexMcp(context) {
   const configPath = join6(context.codexHome, "config.toml");
   const snippet = buildCodexMcpToml(context.mcpCommand, context.withOpenRouter);
   const current = await readOptionalFile(configPath);
-  if (hasCodexMcpContent(current)) {
+  const existing = inspectCodexMcpContent(current, configPath, context.cwd, context.home);
+  if (existing) {
+    return ensureExistingCodexMcp(context, current, existing);
+  }
+  const appendSafety = inspectCodexAppendSafety(current, context.cwd, context.home);
+  if (!appendSafety.ok) {
     return {
       kind: "mcp",
-      registration: "preserved",
+      registration: "blocked",
       title: "Codex MCP",
-      status: "skipped",
+      status: "conflict",
       path: configPath,
-      detail: codexMcpStatusFromContent(current) === "disabled" ? disabledCodexMcpDetail(configPath) : "existing [mcp_servers.kyoso] kept"
+      detail: appendSafety.detail
     };
   }
   const detail = diffForAppend(configPath, snippet);
@@ -188443,9 +188794,18 @@ async function ensureCodexMcp(context) {
       title: "Codex MCP",
       status: "dry-run",
       path: configPath,
-      detail
+      detail: `${detail}${bunxVerificationPendingDetail(context, context.mcpCommand)}`
     };
   }
+  const unsupportedBunx = unsupportedBunxResult(context, "Codex MCP", configPath, context.mcpCommand);
+  if (unsupportedBunx)
+    return unsupportedBunx;
+  if (context.bunxProbe?.status === "verified") {
+    const latest = await readOptionalFile(configPath);
+    if (latest !== current) {
+      return migrationConflictResult("Codex MCP", configPath, "Codex MCP config changed while bunx verification; it was not overwritten.");
+    }
+  }
   const separator = current.length > 0 && !current.endsWith(`
 `) ? `
 
@@ -188466,18 +188826,36 @@ async function ensureClaudeMcp(context) {
     return ensureClaudeGlobalMcp(context);
   }
   const configPath = join6(context.cwd, ".mcp.json");
-  const current = await readJsonObject(configPath);
-  const mcpServers = recordValue(current.mcpServers);
-  if (isRecord9(mcpServers.kyoso)) {
+  const userConfig = detectClaudeMcp(join6(context.home, ".claude.json"), context.cwd, context.home);
+  const applicableUserRegistrations = userConfig.registrations.filter((registration) => registration.status !== "disabled");
+  if (applicableUserRegistrations.length > 0) {
+    return claudeProjectMcpScopeConflictResult(configPath, {
+      ...userConfig,
+      registrations: applicableUserRegistrations,
+      paths: [
+        ...new Set(applicableUserRegistrations.map((registration) => registration.path))
+      ]
+    });
+  }
+  const content = await readOptionalFile(configPath);
+  let current;
+  try {
+    current = parseJsonObject(configPath, content);
+  } catch (error51) {
     return {
       kind: "mcp",
-      registration: "preserved",
+      registration: "blocked",
       title: "Claude Code MCP",
-      status: "skipped",
+      status: "conflict",
       path: configPath,
-      detail: mcpEntryStatus(mcpServers.kyoso) === "disabled" ? disabledClaudeMcpDetail(configPath) : "existing mcpServers.kyoso kept"
+      detail: `Claude Code MCP config could not be parsed and was left unchanged: ${error51 instanceof Error ? error51.message : String(error51)}`
     };
   }
+  const mcpServers = recordValue(current.mcpServers);
+  const existing = inspectClaudeProjectMcp(current, configPath);
+  if (existing) {
+    return ensureExistingClaudeProjectMcp(context, content, existing);
+  }
   const next = {
     ...current,
     mcpServers: {
@@ -188493,9 +188871,19 @@ async function ensureClaudeMcp(context) {
       title: "Claude Code MCP",
       status: "dry-run",
       path: configPath,
-      detail
+      detail: `${detail}${bunxVerificationPendingDetail(context, context.mcpCommand)}`
     };
   }
+  const unsupportedBunx = unsupportedBunxResult(context, "Claude Code MCP", configPath, context.mcpCommand);
+  if (unsupportedBunx)
+    return unsupportedBunx;
+  if (context.bunxProbe?.status === "verified") {
+    const latest = await readOptionalFile(configPath);
+    if (latest !== content) {
+      return migrationConflictResult("Claude Code MCP", configPath, "Claude Code MCP config changed while bunx verification; it was not overwritten.");
+    }
+  }
+  await mkdir5(dirname8(configPath), { recursive: true });
   await writeFile4(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   return {
@@ -188507,6 +188895,166 @@ async function ensureClaudeMcp(context) {
     detail
   };
 }
+async function ensureExistingCodexMcp(context, current, existing) {
+  const currentBunxVerification = verifyCurrentBunxRegistration(context, "Codex MCP", existing);
+  if (currentBunxVerification)
+    return currentBunxVerification;
+  if (existing.invocation.kind !== "legacy") {
+    return preservedMcpResult("Codex MCP", existing, codexPreservedDetail(existing));
+  }
+  const replacement = migrationReplacementForContext(context, existing.invocation);
+  if (!replacement) {
+    return preservedMcpResult("Codex MCP", existing, codexPreservedDetail(existing));
+  }
+  const detail = legacyMigrationDetail(existing.path, existing.invocation, replacement);
+  if (!context.write) {
+    return {
+      kind: "mcp",
+      registration: "preserved",
+      title: "Codex MCP",
+      status: "dry-run",
+      path: existing.path,
+      detail: `${detail}${bunxVerificationPendingDetail(context, replacement)}`
+    };
+  }
+  if (!context.force || context.customCommand) {
+    return preservedMcpResult("Codex MCP", existing, `${detail}
+Legacy registration was kept. Re-run with --write --force to migrate this exact invocation.`);
+  }
+  if (requiresExplicitBunxRunnerForMigration(context, replacement)) {
+    return preservedMcpResult("Codex MCP", existing, `${detail}
+Legacy Bun registration was kept. Re-run with --write --runner bunx --force to verify and migrate this exact invocation, or with --runner npx --force to migrate it using npx.`);
+  }
+  const unsupportedBunx = unsupportedBunxResult(context, "Codex MCP", existing.path, replacement, { migration: true });
+  if (unsupportedBunx)
+    return unsupportedBunx;
+  const safety = await inspectMigrationFile(existing.path);
+  if (!safety.ok) {
+    return preservedMcpResult("Codex MCP", existing, `${detail}
+${safety.detail}`);
+  }
+  if (context.beforeManualMcpWrite) {
+    await context.beforeManualMcpWrite(existing.path);
+  }
+  const latest = await readOptionalFile(existing.path);
+  if (latest !== current) {
+    return migrationConflictResult("Codex MCP", existing.path, "Codex MCP config changed after inspection; it was not overwritten.");
+  }
+  const next = patchCodexLegacyInvocation(latest, replacement);
+  if (!next) {
+    return preservedMcpResult("Codex MCP", existing, `${detail}
+The TOML shape is not a safe single-line legacy target; migrate it manually.`);
+  }
+  const verified = inspectCodexMcpContent(next, existing.path, context.cwd, context.home);
+  if (!isCurrentMcpCommand(verified?.invocation, replacement)) {
+    return preservedMcpResult("Codex MCP", existing, `${detail}
+The proposed TOML patch could not be verified; it was not written.`);
+  }
+  try {
+    await writeFileAtomically(existing.path, next, safety.safety, latest, {
+      beforeCommit: context.beforeManualMcpCommit,
+      afterExpectedContentsCheck: context.afterManualMcpValidation,
+      beforeRename: context.beforeManualMcpRename,
+      replace: context.manualMcpRename
+    });
+  } catch (error51) {
+    if (error51 instanceof MigrationCommittedError) {
+      return migrationConflictResult("Codex MCP", existing.path, "Codex MCP migration may have been committed but could not be verified; inspect the current config before retrying.");
+    }
+    if (error51 instanceof MigrationConflictError) {
+      return migrationConflictResult("Codex MCP", existing.path, "Codex MCP config changed before migration could be committed; it was not overwritten.");
+    }
+    throw error51;
+  }
+  return {
+    kind: "mcp",
+    registration: "migrated",
+    title: "Codex MCP",
+    status: "updated",
+    path: existing.path,
+    detail: "migrated exact legacy [mcp_servers.kyoso] invocation to explicit package/executable args"
+  };
+}
+async function ensureExistingClaudeProjectMcp(context, content, existing) {
+  const currentBunxVerification = verifyCurrentBunxRegistration(context, "Claude Code MCP", existing);
+  if (currentBunxVerification)
+    return currentBunxVerification;
+  if (existing.invocation.kind !== "legacy") {
+    return preservedMcpResult("Claude Code MCP", existing, claudePreservedDetail(existing));
+  }
+  const replacement = migrationReplacementForContext(context, existing.invocation);
+  if (!replacement) {
+    return preservedMcpResult("Claude Code MCP", existing, claudePreservedDetail(existing));
+  }
+  const detail = legacyMigrationDetail(existing.path, existing.invocation, replacement);
+  if (!context.write) {
+    return {
+      kind: "mcp",
+      registration: "preserved",
+      title: "Claude Code MCP",
+      status: "dry-run",
+      path: existing.path,
+      detail: `${detail}${bunxVerificationPendingDetail(context, replacement)}`
+    };
+  }
+  if (!context.force || context.customCommand) {
+    return preservedMcpResult("Claude Code MCP", existing, `${detail}
+Legacy registration was kept. Re-run with --write --force to migrate this exact invocation.`);
+  }
+  if (requiresExplicitBunxRunnerForMigration(context, replacement)) {
+    return preservedMcpResult("Claude Code MCP", existing, `${detail}
+Legacy Bun registration was kept. Re-run with --write --runner bunx --force to verify and migrate this exact invocation, or with --runner npx --force to migrate it using npx.`);
+  }
+  const unsupportedBunx = unsupportedBunxResult(context, "Claude Code MCP", existing.path, replacement, { migration: true });
+  if (unsupportedBunx)
+    return unsupportedBunx;
+  const safety = await inspectMigrationFile(existing.path);
+  if (!safety.ok) {
+    return preservedMcpResult("Claude Code MCP", existing, `${detail}
+${safety.detail}`);
+  }
+  if (context.beforeManualMcpWrite) {
+    await context.beforeManualMcpWrite(existing.path);
+  }
+  const latest = await readOptionalFile(existing.path);
+  if (latest !== content) {
+    return migrationConflictResult("Claude Code MCP", existing.path, "Claude Code MCP config changed after inspection; it was not overwritten.");
+  }
+  const next = patchClaudeProjectMcpInvocation(latest, replacement);
+  if (!next) {
+    return preservedMcpResult("Claude Code MCP", existing, `${detail}
+The JSON shape is not a safe exact legacy target; migrate it manually.`);
+  }
+  const verified = inspectClaudeProjectMcp(parseJsonObject(existing.path, next), existing.path);
+  if (!isCurrentMcpCommand(verified?.invocation, replacement)) {
+    return preservedMcpResult("Claude Code MCP", existing, `${detail}
+The proposed JSON patch could not be verified; it was not written.`);
+  }
+  try {
+    await writeFileAtomically(existing.path, next, safety.safety, latest, {
+      beforeCommit: context.beforeManualMcpCommit,
+      afterExpectedContentsCheck: context.afterManualMcpValidation,
+      beforeRename: context.beforeManualMcpRename,
+      replace: context.manualMcpRename
+    });
+  } catch (error51) {
+    if (error51 instanceof MigrationCommittedError) {
+      return migrationConflictResult("Claude Code MCP", existing.path, "Claude Code MCP migration may have been committed but could not be verified; inspect the current config before retrying.");
+    }
+    if (error51 instanceof MigrationConflictError) {
+      return migrationConflictResult("Claude Code MCP", existing.path, "Claude Code MCP config changed before migration could be committed; it was not overwritten.");
+    }
+    throw error51;
+  }
+  return {
+    kind: "mcp",
+    registration: "migrated",
+    title: "Claude Code MCP",
+    status: "updated",
+    path: existing.path,
+    detail: "migrated exact legacy mcpServers.kyoso invocation to explicit package/executable args"
+  };
+}
 function ensureClaudeGlobalMcp(context) {
   const configPath = join6(context.home, ".claude.json");
   const existingMcp = detectClaudeMcp(configPath, context.cwd, context.home);
@@ -188517,7 +189065,7 @@ function ensureClaudeGlobalMcp(context) {
       title: "Claude Code MCP",
       status: "skipped",
       path: configPath,
-      detail: existingMcp.status === "disabled" ? disabledClaudeMcpDetail(configPath) : "existing mcpServers.kyoso kept"
+      detail: existingMcp.status === "disabled" ? disabledClaudeMcpDetail(configPath) : claudeGlobalMcpPreservedDetail(existingMcp)
     };
   }
   const json2 = JSON.stringify(buildClaudeMcpEntry(context.mcpCommand, context.withOpenRouter));
@@ -188530,9 +189078,12 @@ function ensureClaudeGlobalMcp(context) {
       title: "Claude Code MCP",
       status: "dry-run",
       path: configPath,
-      detail: commandLine
+      detail: `${commandLine}${bunxVerificationPendingDetail(context, context.mcpCommand)}`
     };
   }
+  const unsupportedBunx = unsupportedBunxResult(context, "Claude Code MCP", configPath, context.mcpCommand);
+  if (unsupportedBunx)
+    return unsupportedBunx;
   const result = spawnSync2("claude", args, { encoding: "utf8" });
   if (result.status !== 0) {
     throw new Error(result.stderr || result.stdout || "claude mcp add-json failed");
@@ -188546,6 +189097,27 @@ function ensureClaudeGlobalMcp(context) {
     detail: commandLine
   };
 }
+function claudeGlobalMcpPreservedDetail(detection) {
+  if (detection.registrations.length !== 1) {
+    return "Multiple existing mcpServers.kyoso registrations were kept; their effective precedence is not inferred.";
+  }
+  const registration = detection.registrations[0];
+  if (registration?.invocation.kind !== "legacy") {
+    return "existing mcpServers.kyoso kept";
+  }
+  const scope = registration.scope === "claude-global" ? "user" : "project-scoped user-config";
+  return `existing ${scope} mcpServers.kyoso uses legacy package-runner arguments and was kept. Automatic migration supports only a project .mcp.json; update ${registration.path} manually.`;
+}
+function claudeProjectMcpScopeConflictResult(projectPath, userConfig) {
+  return {
+    kind: "mcp",
+    registration: "preserved",
+    title: "Claude Code MCP",
+    status: "skipped",
+    path: projectPath,
+    detail: `Claude user-config MCP registration${userConfig.registrations.length === 1 ? "" : "s"} at ${userConfig.paths.join(", ")} ${userConfig.registrations.length === 1 ? "was" : "were"} kept. Project setup does not infer effective precedence; update the intended scope manually.`
+  };
+}
 async function ensureSkill(context, client, title) {
   const result = await ensureManagedSkill({
     sourceDir: context.sourceSkillDir,
@@ -188570,8 +189142,8 @@ function renderSetupOverview(context) {
     "Kyoso setup",
     "",
     "Clients",
-    `  codex: MCP ${statusWord(detected.codex.mcp)}, skill ${statusWord(detected.codex.skill)}`,
-    `  claude-code: MCP ${statusWord(detected["claude-code"].mcp)}, skill ${statusWord(detected["claude-code"].skill)}`,
+    `  codex: MCP ${setupOverviewMcpStatus(detected.codex, context)}, skill ${statusWord(detected.codex.skill)}`,
+    `  claude-code: MCP ${setupOverviewMcpStatus(detected["claude-code"], context)}, skill ${statusWord(detected["claude-code"].skill)}`,
     "",
     "Commands",
     "  kyoso setup codex [--write] [--with-openrouter] [--runner npx|bunx] [--command <command>] [--global] [--force]",
@@ -188584,151 +189156,852 @@ function renderSetupOverview(context) {
   ].join(`
 `);
 }
-function renderResults(context, results) {
-  const mcpSteps = results.filter((result) => result.kind === "mcp");
-  const includesGeneratedMcp = mcpSteps.some((result) => result.registration === "generated");
-  const includesGeneratedCodexMcp = mcpSteps.some((result) => result.registration === "generated" && result.title === "Codex MCP");
-  const includesPreservedMcp = mcpSteps.some((result) => result.registration === "preserved");
-  return [
-    "Kyoso setup",
-    "",
-    ...results.flatMap((result) => [
-      `${result.title}: ${result.status}${result.path ? ` (${result.path})` : ""}`,
-      ...result.detail ? indent(result.detail).split(`
-`) : []
-    ]),
-    ...mcpSteps.length > 0 ? [
-      "",
-      "Credential scope",
-      ...includesGeneratedMcp ? [
-        context.withOpenRouter ? "  Newly generated and dry-run MCP registrations include OPENROUTER_API_KEY because --with-openrouter was set." : "  Newly generated and dry-run MCP registrations omit OPENROUTER_API_KEY. Use --with-openrouter before writing a new registration to include it."
-      ] : [],
-      ...includesGeneratedCodexMcp ? [
-        "  Newly generated and dry-run Codex MCP registrations intentionally forward CODEX_ACCESS_TOKEN for default Codex authentication; OpenRouter mode withholds it from the Codex child."
-      ] : [],
-      ...includesPreservedMcp ? [
-        "  Existing MCP registrations were preserved unchanged; --with-openrouter does not edit them."
-      ] : [],
-      "  Use --with-openrouter only when OpenRouter is intentionally selected."
-    ] : []
-  ].join(`
-`);
+function setupOverviewMcpStatus(detection, context) {
+  if (detection.manualMcpStatus === "missing")
+    return "missing";
+  if (detection.manualMcpRegistrations.length !== 1)
+    return "unverified";
+  const registration = detection.manualMcpRegistrations[0];
+  if (!registration)
+    return "unverified";
+  if (registration.status === "disabled")
+    return "disabled";
+  if (registration.status !== "enabled")
+    return "unverified";
+  const invocation = registration.invocation;
+  if (invocation.kind === "legacy")
+    return "repair required (legacy)";
+  if (invocation.kind === "custom")
+    return "custom/unverified";
+  if (invocation.kind !== "current")
+    return "unverified";
+  if (invocation.runner === "npx") {
+    return commandExists2("npx", context.env) ? "ok" : "npx missing";
+  }
+  if (invocation.runner === "bunx") {
+    return commandExists2("bunx", context.env) ? "bunx unverified" : "bunx missing";
+  }
+  return "unverified";
+}
+function renderResults(context, results) {
+  const mcpSteps = results.filter((result) => result.kind === "mcp");
+  const includesGeneratedMcp = mcpSteps.some((result) => result.registration === "generated");
+  const includesGeneratedCodexMcp = mcpSteps.some((result) => result.registration === "generated" && result.title === "Codex MCP");
+  const includesPreservedMcp = mcpSteps.some((result) => result.registration === "preserved");
+  return [
+    "Kyoso setup",
+    "",
+    ...results.flatMap((result) => [
+      `${result.title}: ${result.status}${result.path ? ` (${result.path})` : ""}`,
+      ...result.detail ? indent(result.detail).split(`
+`) : []
+    ]),
+    ...mcpSteps.length > 0 ? [
+      "",
+      "Credential scope",
+      ...includesGeneratedMcp ? [
+        context.withOpenRouter ? "  Newly generated and dry-run MCP registrations include OPENROUTER_API_KEY because --with-openrouter was set." : "  Newly generated and dry-run MCP registrations omit OPENROUTER_API_KEY. Use --with-openrouter before writing a new registration to include it."
+      ] : [],
+      ...includesGeneratedCodexMcp ? [
+        "  Newly generated and dry-run Codex MCP registrations intentionally forward CODEX_ACCESS_TOKEN for default Codex authentication; OpenRouter mode withholds it from the Codex child."
+      ] : [],
+      ...includesPreservedMcp ? [
+        "  Existing MCP registrations were preserved unchanged; --with-openrouter does not edit them."
+      ] : [],
+      "  Use --with-openrouter only when OpenRouter is intentionally selected."
+    ] : []
+  ].join(`
+`);
+}
+function parseClient(client) {
+  if (client === undefined)
+    return;
+  if (client === "codex" || client === "claude-code")
+    return client;
+  throw new Error(`Invalid setup client "${client}". Expected codex or claude-code.`);
+}
+function validateSkillOnlyOptions(options, client) {
+  if (!options.skillOnly)
+    return;
+  if (!client) {
+    throw new Error("--skill-only requires setup client codex or claude-code.");
+  }
+  if (options.runner !== undefined) {
+    throw new Error("--skill-only cannot be combined with --runner.");
+  }
+  if (options.command !== undefined) {
+    throw new Error("--skill-only cannot be combined with --command.");
+  }
+  if (options.withOpenRouter) {
+    throw new Error("--skill-only cannot be combined with --with-openrouter.");
+  }
+}
+function parseRunner(runner) {
+  if (runner === undefined || runner === "npx")
+    return "npx";
+  if (runner === "bunx")
+    return "bunx";
+  throw new Error(`Invalid --runner value "${runner}". Expected npx or bunx.`);
+}
+function parseCommandSpec(value) {
+  const parts = splitCommand(value);
+  const [command, ...args] = parts;
+  if (!command)
+    throw new Error("--command must not be empty");
+  return { command, args };
+}
+function splitCommand(value) {
+  const parts = [];
+  let current = "";
+  let quote;
+  for (const char of value.trim()) {
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote)
+    throw new Error("--command has an unterminated quote");
+  if (current.length > 0)
+    parts.push(current);
+  return parts;
+}
+function resolveBundledSkillDir() {
+  const start = dirname8(fileURLToPath(import.meta.url));
+  let current = start;
+  for (let depth = 0;depth < 5; depth += 1) {
+    const candidate = join6(current, ".agents", "skills", "kyoso-review");
+    if (existsSync2(join6(candidate, "SKILL.md")))
+      return candidate;
+    current = dirname8(current);
+  }
+  throw new Error("Bundled kyoso-review skill was not found in this package.");
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile6(path, "utf8");
+  } catch (error51) {
+    if (isMissingPathError4(error51))
+      return "";
+    throw error51;
+  }
+}
+function parseJsonObject(path, content) {
+  if (content.trim().length === 0)
+    return {};
+  const parsed = JSON.parse(content);
+  if (!isRecord10(parsed))
+    throw new Error(`${path} must contain a JSON object`);
+  return parsed;
+}
+function inspectCodexAppendSafety(content, cwd, home) {
+  if (content.trim().length === 0)
+    return { ok: true };
+  try {
+    const parsed = parse5(content);
+    if (!isRecord10(parsed)) {
+      return {
+        ok: false,
+        detail: "Codex config is not a TOML object and was left unchanged."
+      };
+    }
+    if (hasUnprobedProjectIntegrationOverride(parsed, cwd, home)) {
+      return {
+        ok: false,
+        detail: "Codex has a project-scoped MCP or Plugin override; the global config was left unchanged."
+      };
+    }
+    if ("mcp_servers" in parsed && !isRecord10(parsed.mcp_servers)) {
+      return {
+        ok: false,
+        detail: "Codex mcp_servers is malformed and was left unchanged."
+      };
+    }
+    if (isRecord10(parsed.mcp_servers) && "kyoso" in parsed.mcp_servers) {
+      return {
+        ok: false,
+        detail: "Codex already defines mcp_servers.kyoso in a form setup cannot safely extend; migrate it manually."
+      };
+    }
+    if (hasTomlMcpServersAssignment(content)) {
+      return {
+        ok: false,
+        detail: "Codex defines mcp_servers with an inline assignment setup cannot safely extend; add the registration manually."
+      };
+    }
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      detail: "Codex config could not be parsed and was left unchanged."
+    };
+  }
+}
+function hasTomlMcpServersAssignment(content) {
+  return /^[ \t]*(?:mcp_servers|"mcp_servers")[ \t]*=/m.test(content);
+}
+function inspectCodexMcpContent(content, path, cwd, home) {
+  if (!hasCodexMcpContent(content))
+    return;
+  try {
+    const parsed = parse5(content);
+    if (hasUnprobedProjectIntegrationOverride(parsed, cwd, home)) {
+      return manualMcpRegistration({
+        path,
+        scope: "codex-global",
+        status: "unknown",
+        value: undefined
+      });
+    }
+    if (!isRecord10(parsed) || !isRecord10(parsed.mcp_servers)) {
+      return manualMcpRegistration({
+        path,
+        scope: "codex-global",
+        status: "unknown",
+        value: undefined
+      });
+    }
+    if (!("kyoso" in parsed.mcp_servers))
+      return;
+    return manualMcpRegistration({
+      path,
+      scope: "codex-global",
+      status: mcpEntryStatus(parsed.mcp_servers.kyoso),
+      value: parsed.mcp_servers.kyoso
+    });
+  } catch {
+    return manualMcpRegistration({
+      path,
+      scope: "codex-global",
+      status: "unknown",
+      value: undefined
+    });
+  }
+}
+function inspectClaudeProjectMcp(current, path) {
+  if (!("mcpServers" in current))
+    return;
+  if (!isRecord10(current.mcpServers)) {
+    return manualMcpRegistration({
+      path,
+      scope: "claude-project",
+      status: "unknown",
+      value: undefined
+    });
+  }
+  if (!("kyoso" in current.mcpServers))
+    return;
+  return manualMcpRegistration({
+    path,
+    scope: "claude-project",
+    status: mcpEntryStatus(current.mcpServers.kyoso),
+    value: current.mcpServers.kyoso
+  });
+}
+function manualMcpRegistration(options) {
+  const { value, ...registration } = options;
+  const invocation = inspectManualMcpInvocation(value);
+  return {
+    ...registration,
+    invocation,
+    autoMigrationEligible: (options.scope === "codex-global" || options.scope === "claude-project") && invocation.kind === "legacy"
+  };
+}
+function preservedMcpResult(title, registration, detail) {
+  return {
+    kind: "mcp",
+    registration: "preserved",
+    title,
+    status: "skipped",
+    path: registration.path,
+    detail
+  };
+}
+function codexPreservedDetail(registration) {
+  if (registration.status === "disabled") {
+    return disabledCodexMcpDetail(registration.path);
+  }
+  if (registration.invocation.kind === "current") {
+    return "existing [mcp_servers.kyoso] uses the current explicit package/executable invocation and was kept.";
+  }
+  if (registration.invocation.kind === "legacy") {
+    return "existing [mcp_servers.kyoso] uses a legacy invocation and was kept unchanged.";
+  }
+  return `existing [mcp_servers.kyoso] is ${formatInvocationKind(registration.invocation.kind)} and was kept unchanged. ${registration.invocation.reason}`;
+}
+function claudePreservedDetail(registration) {
+  if (registration.status === "disabled") {
+    return disabledClaudeMcpDetail(registration.path);
+  }
+  if (registration.invocation.kind === "current") {
+    return "existing mcpServers.kyoso uses the current explicit package/executable invocation and was kept.";
+  }
+  if (registration.invocation.kind === "legacy") {
+    return "existing mcpServers.kyoso uses a legacy invocation and was kept unchanged.";
+  }
+  return `existing mcpServers.kyoso is ${formatInvocationKind(registration.invocation.kind)} and was kept unchanged. ${registration.invocation.reason}`;
+}
+function formatInvocationKind(kind) {
+  if (kind === "custom")
+    return "custom/unverified";
+  return kind;
+}
+function legacyMigrationDetail(path, invocation, replacement) {
+  const legacyArgs = invocation.legacyArgs;
+  if (!invocation.runner || !legacyArgs) {
+    return "legacy package-runner invocation detected; only --write --force may migrate it. The migration preview is unavailable because its exact command arguments could not be reconstructed.";
+  }
+  return [
+    "legacy package-runner invocation detected; only --write --force may migrate it.",
+    `--- ${formatMigrationPreviewValue(path)}`,
+    `+++ ${formatMigrationPreviewValue(path)}`,
+    "@@ Kyoso MCP invocation",
+    `- command = ${formatMigrationPreviewValue(invocation.runner)}`,
+    `- args = ${formatMigrationPreviewArgs(legacyArgs)}`,
+    `+ command = ${formatMigrationPreviewValue(replacement.command)}`,
+    `+ args = ${formatMigrationPreviewArgs(replacement.args)}`,
+    "Only the Kyoso command and arguments are shown; other configuration values remain unchanged."
+  ].join(`
+`);
+}
+function patchCodexLegacyInvocation(content, replacement) {
+  const tableMatches = [...content.matchAll(/^\s*\[mcp_servers\.kyoso]\s*$/gm)];
+  if (tableMatches.length !== 1)
+    return;
+  const table = tableMatches[0];
+  if (table?.index === undefined)
+    return;
+  const bodyStart = table.index + table[0].length;
+  const remaining = content.slice(bodyStart);
+  const nextTableOffset = remaining.search(/^\s*\[/m);
+  const bodyEnd = nextTableOffset === -1 ? content.length : bodyStart + nextTableOffset;
+  const body = content.slice(bodyStart, bodyEnd);
+  const commandMatches = [
+    ...body.matchAll(/^([ \t]*command[ \t]*=[ \t]*)"[^"\r\n]*"([ \t]*(?:#.*)?)(\r?\n|$)/gm)
+  ];
+  const argsMatches = [
+    ...body.matchAll(/^([ \t]*args[ \t]*=[ \t]*)([^\r\n]*)(\r?\n|$)/gm)
+  ];
+  if (commandMatches.length !== 1 || argsMatches.length !== 1)
+    return;
+  const argsMatch = argsMatches[0];
+  const argsLine = argsMatch?.[0];
+  const argsPrefix = argsMatch?.[1];
+  const argsValue = argsMatch?.[2];
+  const argsNewline = argsMatch?.[3];
+  if (argsLine === undefined || argsPrefix === undefined || argsValue === undefined || argsNewline === undefined) {
+    return;
+  }
+  const patchedArgsValue = patchTomlInlineArrayValue(argsValue, replacement.args);
+  if (patchedArgsValue === undefined)
+    return;
+  const commandPatched = body.replace(/^([ \t]*command[ \t]*=[ \t]*)"[^"\r\n]*"([ \t]*(?:#.*)?)(\r?\n|$)/m, (_line, prefix, suffix, newline) => `${prefix}${JSON.stringify(replacement.command)}${suffix}${newline}`);
+  const nextBody = commandPatched.replace(argsLine, `${argsPrefix}${patchedArgsValue}${argsNewline}`);
+  return `${content.slice(0, bodyStart)}${nextBody}${content.slice(bodyEnd)}`;
+}
+function patchTomlInlineArrayValue(value, replacement) {
+  const closingIndex = tomlInlineArrayClosingIndex(value);
+  if (closingIndex === undefined)
+    return;
+  const suffix = value.slice(closingIndex + 1);
+  if (!/^[ \t]*(?:#.*)?$/.test(suffix))
+    return;
+  return `${JSON.stringify(replacement)}${suffix}`;
+}
+function tomlInlineArrayClosingIndex(value) {
+  if (!value.startsWith("["))
+    return;
+  let depth = 0;
+  let quote;
+  for (let index = 0;index < value.length; index += 1) {
+    const character = value[index];
+    if (character === undefined)
+      return;
+    if (quote) {
+      if (quote === '"' && character === "\\") {
+        index += 1;
+        continue;
+      }
+      if (character === quote) {
+        if (quote === "'" && value[index + 1] === "'") {
+          index += 1;
+          continue;
+        }
+        quote = undefined;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "[") {
+      depth += 1;
+      continue;
+    }
+    if (character === "]") {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+      if (depth < 0)
+        return;
+    }
+  }
+  return;
+}
+function isCurrentMcpCommand(invocation, replacement) {
+  if (invocation?.kind !== "current" || invocation.runner !== replacement.command) {
+    return false;
+  }
+  const packageSpec = replacement.command === "npx" ? replacement.args[1]?.slice("--package=".length) : replacement.args[1];
+  return invocation.packageSpec === packageSpec;
+}
+function migrationReplacementForContext(context, invocation) {
+  const replacement = invocation.replacement;
+  if (!replacement || context.customCommand || !context.runnerExplicit || !isKyosoPackageRunner(context.mcpCommand.command) || context.mcpCommand.command === replacement.command) {
+    return replacement;
+  }
+  const packageSpec = invocation.packageSpec;
+  if (packageSpec === undefined || packageSpec !== KYOSO_PACKAGE_NAME && !packageSpec.startsWith(`${KYOSO_PACKAGE_NAME}@`)) {
+    return replacement;
+  }
+  const version2 = packageSpec === KYOSO_PACKAGE_NAME ? undefined : packageSpec.slice(`${KYOSO_PACKAGE_NAME}@`.length);
+  return buildKyosoPackageCommand({
+    runner: context.mcpCommand.command,
+    ...version2 === undefined ? {} : { version: version2 },
+    cliArgs: ["mcp"]
+  });
+}
+function isKyosoPackageRunner(value) {
+  return value === "npx" || value === "bunx";
+}
+function patchClaudeProjectMcpInvocation(content, replacement) {
+  try {
+    JSON.parse(content);
+    const root = scanJsonValue(content, skipJsonWhitespace(content, 0));
+    if (skipJsonWhitespace(content, root.end) !== content.length)
+      return;
+    const mcpServers = singleJsonObjectProperty(root, "mcpServers");
+    const kyoso = mcpServers && singleJsonObjectProperty(mcpServers, "kyoso");
+    const command = kyoso && singleJsonProperty(kyoso, "command");
+    const args = kyoso && singleJsonProperty(kyoso, "args");
+    if (!command || !args)
+      return;
+    return replaceJsonValueSpans(content, [
+      { ...command.value, replacement: JSON.stringify(replacement.command) },
+      { ...args.value, replacement: JSON.stringify(replacement.args) }
+    ]);
+  } catch {
+    return;
+  }
+}
+function scanJsonValue(content, start) {
+  const index = skipJsonWhitespace(content, start);
+  const character = content[index];
+  if (character === "{")
+    return scanJsonObject(content, index);
+  if (character === "[")
+    return scanJsonArray(content, index);
+  if (character === '"') {
+    const end2 = scanJsonStringEnd(content, index);
+    return { kind: "scalar", start: index, end: end2 };
+  }
+  let end = index;
+  while (end < content.length && !/[\s,\]}]/.test(content[end] ?? "")) {
+    end += 1;
+  }
+  if (end === index)
+    throw new Error("expected JSON value");
+  return { kind: "scalar", start: index, end };
+}
+function scanJsonObject(content, start) {
+  let index = skipJsonWhitespace(content, start + 1);
+  const entries = [];
+  if (content[index] === "}") {
+    return { kind: "object", start, end: index + 1, entries };
+  }
+  for (;; ) {
+    if (content[index] !== '"')
+      throw new Error("expected JSON object key");
+    const keyEnd = scanJsonStringEnd(content, index);
+    const key = JSON.parse(content.slice(index, keyEnd));
+    if (typeof key !== "string")
+      throw new Error("invalid JSON object key");
+    index = skipJsonWhitespace(content, keyEnd);
+    if (content[index] !== ":")
+      throw new Error("expected JSON object separator");
+    const value = scanJsonValue(content, index + 1);
+    entries.push({ key, value });
+    index = skipJsonWhitespace(content, value.end);
+    if (content[index] === "}") {
+      return { kind: "object", start, end: index + 1, entries };
+    }
+    if (content[index] !== ",")
+      throw new Error("expected JSON object delimiter");
+    index = skipJsonWhitespace(content, index + 1);
+  }
+}
+function scanJsonArray(content, start) {
+  let index = skipJsonWhitespace(content, start + 1);
+  if (content[index] === "]")
+    return { kind: "array", start, end: index + 1 };
+  for (;; ) {
+    const value = scanJsonValue(content, index);
+    index = skipJsonWhitespace(content, value.end);
+    if (content[index] === "]")
+      return { kind: "array", start, end: index + 1 };
+    if (content[index] !== ",")
+      throw new Error("expected JSON array delimiter");
+    index = skipJsonWhitespace(content, index + 1);
+  }
+}
+function scanJsonStringEnd(content, start) {
+  let escaped = false;
+  for (let index = start + 1;index < content.length; index += 1) {
+    const character = content[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === '"')
+      return index + 1;
+  }
+  throw new Error("unterminated JSON string");
+}
+function skipJsonWhitespace(content, start) {
+  let index = start;
+  while (index < content.length && /\s/.test(content[index] ?? ""))
+    index += 1;
+  return index;
+}
+function singleJsonObjectProperty(object2, key) {
+  const property = singleJsonProperty(object2, key);
+  return property?.value.kind === "object" ? property.value : undefined;
+}
+function singleJsonProperty(object2, key) {
+  if (object2.kind !== "object")
+    return;
+  const matches = object2.entries?.filter((entry) => entry.key === key) ?? [];
+  return matches.length === 1 ? matches[0] : undefined;
+}
+function replaceJsonValueSpans(content, replacements) {
+  const sorted = [...replacements].sort((left, right) => right.start - left.start);
+  if (sorted[0]?.start === sorted[1]?.start)
+    return;
+  let next = content;
+  for (const replacement of sorted) {
+    next = `${next.slice(0, replacement.start)}${replacement.replacement}${next.slice(replacement.end)}`;
+  }
+  return next;
+}
+async function inspectMigrationFile(path, options = {}) {
+  try {
+    const before = await lstat3(path);
+    if (!isSafeMigrationFile(before, options.expectedSafety, options.expectedNlink)) {
+      return {
+        ok: false,
+        detail: "The existing config is not an unlinked regular file and was left for manual migration."
+      };
+    }
+    if (options.expectedContents !== undefined) {
+      const contents = await readFile6(path, "utf8");
+      const after = await lstat3(path);
+      if (!isSafeMigrationFile(after, options.expectedSafety, options.expectedNlink) || !sameMigrationFileIdentity(before, after) || contents !== options.expectedContents) {
+        return {
+          ok: false,
+          detail: "The existing config changed after final migration validation and was left unchanged."
+        };
+      }
+      return { ok: true, safety: migrationFileSafety(after) };
+    }
+    return { ok: true, safety: migrationFileSafety(before) };
+  } catch (error51) {
+    return {
+      ok: false,
+      detail: `The existing config could not be safely inspected: ${error51 instanceof Error ? error51.message : String(error51)}`
+    };
+  }
+}
+function isSafeMigrationFile(metadata, expectedSafety, expectedNlink = 1) {
+  if (metadata.isSymbolicLink() || !metadata.isFile() || metadata.nlink !== expectedNlink) {
+    return false;
+  }
+  return expectedSafety === undefined || sameMigrationFileIdentity(metadata, expectedSafety) && (metadata.mode & 511) === expectedSafety.mode;
+}
+function sameMigrationFileIdentity(metadata, expected) {
+  return metadata.dev === expected.dev && metadata.ino === expected.ino;
+}
+function migrationFileSafety(metadata) {
+  return {
+    mode: metadata.mode & 511,
+    dev: metadata.dev,
+    ino: metadata.ino
+  };
+}
+
+class MigrationConflictError extends Error {
+}
+
+class MigrationCommittedError extends Error {
+}
+function migrationConflictResult(title, path, detail) {
+  return {
+    kind: "mcp",
+    registration: "preserved",
+    title,
+    status: "conflict",
+    path,
+    detail
+  };
+}
+async function writeFileAtomically(path, contents, expectedSafety, expectedContents, options) {
+  const directory = dirname8(path);
+  const temporaryPath = join6(directory, `.${basename3(path)}.kyoso-${process.pid}-${randomUUID2()}.tmp`);
+  let handle;
+  let replacementCommitted = false;
+  try {
+    handle = await open(temporaryPath, "wx", expectedSafety.mode);
+    await handle.writeFile(contents, "utf8");
+    await chmod(temporaryPath, expectedSafety.mode);
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    await options.beforeCommit?.(path);
+    await options.afterExpectedContentsCheck?.(path);
+    await options.beforeRename?.(path);
+    const beforeRename = await inspectMigrationFile(path, {
+      expectedContents,
+      expectedSafety
+    });
+    if (!beforeRename.ok) {
+      throw new MigrationConflictError(beforeRename.detail);
+    }
+    try {
+      await (options.replace ?? rename2)(temporaryPath, path);
+      replacementCommitted = true;
+    } catch (error51) {
+      const installed2 = await inspectMigrationFile(path, {
+        expectedContents: contents
+      });
+      if (installed2.ok && installed2.safety.mode === expectedSafety.mode) {
+        throw new MigrationCommittedError("manual MCP migration may have been committed before replacement reported an error");
+      }
+      throw error51;
+    }
+    await syncDirectory(directory);
+    const installed = await inspectMigrationFile(path, {
+      expectedContents: contents
+    });
+    if (!installed.ok || installed.safety.mode !== expectedSafety.mode) {
+      throw new MigrationCommittedError("the replacement config could not be verified after installation");
+    }
+  } catch (error51) {
+    if (error51 instanceof MigrationConflictError || error51 instanceof MigrationCommittedError) {
+      throw error51;
+    }
+    if (replacementCommitted) {
+      throw new MigrationCommittedError(`manual MCP migration may have been committed but could not be verified: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+    throw new MigrationConflictError(`manual MCP migration failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  } finally {
+    await handle?.close().catch(() => {
+      return;
+    });
+    await rm2(temporaryPath, { force: true }).catch(() => {
+      return;
+    });
+  }
+}
+async function syncDirectory(path) {
+  let handle;
+  try {
+    handle = await open(path, "r");
+    await handle.sync();
+  } catch (error51) {
+    if (isUnsupportedDirectorySyncError(error51))
+      return;
+    throw error51;
+  } finally {
+    await handle?.close().catch(() => {
+      return;
+    });
+  }
 }
-function parseClient(client) {
-  if (client === undefined)
+function isUnsupportedDirectorySyncError(error51) {
+  const code = errorCode(error51);
+  return code === "EINVAL" || code === "ENOTSUP" || code === "EOPNOTSUPP" || process.platform === "win32" && code === "EPERM";
+}
+function errorCode(error51) {
+  if (typeof error51 !== "object" || error51 === null || !("code" in error51)) {
     return;
-  if (client === "codex" || client === "claude-code")
-    return client;
-  throw new Error(`Invalid setup client "${client}". Expected codex or claude-code.`);
+  }
+  return typeof error51.code === "string" ? error51.code : undefined;
 }
-function validateSkillOnlyOptions(options, client) {
-  if (!options.skillOnly)
+function unsupportedBunxResult(context, title, path, command, options = {}) {
+  if (!context.write || options.migration && !context.force || context.customCommand || command.command !== "bunx") {
     return;
-  if (!client) {
-    throw new Error("--skill-only requires setup client codex or claude-code.");
   }
-  if (options.runner !== undefined) {
-    throw new Error("--skill-only cannot be combined with --runner.");
+  const probe = ensureBunxProbe(context);
+  if (probe.status === "verified")
+    return;
+  const fallback = formatBunxFallbackCommand(context, title, options);
+  return {
+    kind: "mcp",
+    registration: "blocked",
+    title,
+    status: "skipped",
+    path,
+    detail: `bunx was not verified for explicit package selection (${probe.detail}). No MCP config was written. Use ${fallback}, or install Bun 1.3.14 or newer and retry --runner bunx.`
+  };
+}
+function verifyCurrentBunxRegistration(context, title, existing) {
+  if (!context.write || !context.runnerExplicit || context.customCommand || context.mcpCommand.command !== "bunx" || existing.invocation.kind !== "current" || existing.invocation.runner !== "bunx") {
+    return;
   }
-  if (options.command !== undefined) {
-    throw new Error("--skill-only cannot be combined with --command.");
+  const probe = ensureBunxProbe(context);
+  if (probe.status !== "verified") {
+    return {
+      kind: "mcp",
+      registration: "blocked",
+      title,
+      status: "skipped",
+      path: existing.path,
+      detail: `existing current bunx registration was kept unchanged. bunx could not be verified for explicit package selection (${probe.detail}). Install Bun 1.3.14 or newer before treating this registration as ready.`
+    };
   }
-  if (options.withOpenRouter) {
-    throw new Error("--skill-only cannot be combined with --with-openrouter.");
+  const detail = title === "Codex MCP" ? codexPreservedDetail(existing) : claudePreservedDetail(existing);
+  return preservedMcpResult(title, existing, `${detail} bunx ${probe.version} was verified for explicit package selection; no MCP config bytes changed.`);
+}
+function ensureBunxProbe(context) {
+  return context.bunxProbe ?? (context.bunxProbe = context.bunxVersionProbe({
+    cwd: context.cwd,
+    env: context.env
+  }));
+}
+function requiresExplicitBunxRunnerForMigration(context, command) {
+  return command.command === "bunx" && !context.runnerExplicit;
+}
+function formatBunxFallbackCommand(context, title, options) {
+  const cliArgs = [
+    "setup",
+    title === "Codex MCP" ? "codex" : "claude-code",
+    "--write",
+    "--runner",
+    "npx"
+  ];
+  if (context.scope === "global")
+    cliArgs.push("--global");
+  if (context.withOpenRouter)
+    cliArgs.push("--with-openrouter");
+  if (options.migration)
+    cliArgs.push("--force");
+  return formatKyosoPackageCommand({ runner: "npx", cliArgs });
+}
+function bunxVerificationPendingDetail(context, command) {
+  if (context.customCommand || command.command !== "bunx")
+    return "";
+  if (!context.runnerExplicit) {
+    return `
+Legacy Bun registration will stay unchanged unless you rerun with --write --runner bunx --force to verify and migrate it, or with --runner npx --force to migrate it using npx.`;
   }
+  return `
+Bun 1.3.14 or newer will be verified before any MCP config is written.`;
 }
-function parseRunner(runner) {
-  if (runner === undefined || runner === "npx")
-    return "npx";
-  if (runner === "bunx")
-    return "bunx";
-  throw new Error(`Invalid --runner value "${runner}". Expected npx or bunx.`);
+function formatMigrationPreviewValue(value) {
+  return JSON.stringify(sanitizeTextForDisplay(value));
 }
-function parseCommandSpec(value) {
-  const parts = splitCommand(value);
-  const [command, ...args] = parts;
-  if (!command)
-    throw new Error("--command must not be empty");
-  return { command, args };
+function formatMigrationPreviewArgs(args) {
+  return `[${args.map(formatMigrationPreviewValue).join(", ")}]`;
 }
-function splitCommand(value) {
-  const parts = [];
-  let current = "";
-  let quote;
-  for (const char of value.trim()) {
-    if (quote) {
-      if (char === quote) {
-        quote = undefined;
-      } else {
-        current += char;
-      }
-      continue;
+function probeBunxVersion(options) {
+  const probeDirectory = mkdtempSync(join6(tmpdir2(), "kyoso-bunx-probe-"));
+  try {
+    const result = spawnSync2("bunx", ["--version"], {
+      cwd: probeDirectory,
+      env: sanitizedBunxProbeEnv(options.env, probeDirectory),
+      encoding: "utf8",
+      timeout: 2000,
+      shell: false
+    });
+    const errorCode2 = result.error && "code" in result.error ? result.error.code : undefined;
+    if (errorCode2 === "ENOENT") {
+      return { status: "missing", detail: "bunx was not found on PATH" };
     }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
+    if (errorCode2 === "ETIMEDOUT" || result.signal) {
+      return { status: "timeout", detail: "bunx --version timed out" };
     }
-    if (/\s/.test(char)) {
-      if (current.length > 0) {
-        parts.push(current);
-        current = "";
-      }
-      continue;
+    if (result.status !== 0) {
+      return {
+        status: "failed",
+        detail: `bunx --version exited ${result.status ?? "without a status"}`
+      };
     }
-    current += char;
+    const version2 = result.stdout.trim();
+    if (!/^\d+\.\d+\.\d+$/.test(version2)) {
+      return {
+        status: "invalid",
+        detail: "bunx --version did not return a stable SemVer"
+      };
+    }
+    if (!isCompleteSemVer(version2) || !isMinimumBunVersion(version2, "1.3.14")) {
+      return {
+        status: "unsupported",
+        detail: `bunx ${version2} is older than the verified minimum 1.3.14`
+      };
+    }
+    return { status: "verified", version: version2 };
+  } finally {
+    rmSync(probeDirectory, { force: true, recursive: true });
   }
-  if (quote)
-    throw new Error("--command has an unterminated quote");
-  if (current.length > 0)
-    parts.push(current);
-  return parts;
 }
-function resolveBundledSkillDir() {
-  const start = dirname8(fileURLToPath(import.meta.url));
-  let current = start;
-  for (let depth = 0;depth < 5; depth += 1) {
-    const candidate = join6(current, ".agents", "skills", "kyoso-review");
-    if (existsSync2(join6(candidate, "SKILL.md")))
-      return candidate;
-    current = dirname8(current);
+function sanitizedBunxProbeEnv(env, temporaryDirectory) {
+  const result = {
+    PATH: env.PATH ?? "",
+    HOME: env.HOME ?? "",
+    TMPDIR: temporaryDirectory
+  };
+  for (const key of ["SystemRoot", "ComSpec", "PATHEXT", "WINDIR"]) {
+    if (env[key])
+      result[key] = env[key];
   }
-  throw new Error("Bundled kyoso-review skill was not found in this package.");
+  return result;
 }
-async function readOptionalFile(path) {
-  try {
-    return await readFile6(path, "utf8");
-  } catch (error51) {
-    if (isMissingPathError4(error51))
-      return "";
-    throw error51;
+function isMinimumBunVersion(version2, minimum) {
+  const actualParts = version2.split(".").map(Number);
+  const minimumParts = minimum.split(".").map(Number);
+  for (let index = 0;index < minimumParts.length; index += 1) {
+    const actual = actualParts[index] ?? 0;
+    const required2 = minimumParts[index] ?? 0;
+    if (actual > required2)
+      return true;
+    if (actual < required2)
+      return false;
   }
-}
-async function readJsonObject(path) {
-  const content = await readOptionalFile(path);
-  if (content.trim().length === 0)
-    return {};
-  const parsed = JSON.parse(content);
-  if (!isRecord9(parsed))
-    throw new Error(`${path} must contain a JSON object`);
-  return parsed;
+  return true;
 }
 function hasCodexMcpContent(content) {
   return /^\s*\[mcp_servers\.(?:"kyoso"|kyoso)]\s*$/m.test(content);
 }
-function codexMcpStatusFromContent(content) {
-  try {
-    const parsed = parse5(content);
-    if (!isRecord9(parsed))
-      return "unknown";
-    if (!isRecord9(parsed.mcp_servers))
-      return "missing";
-    if (!("kyoso" in parsed.mcp_servers))
-      return "missing";
-    return mcpEntryStatus(parsed.mcp_servers.kyoso);
-  } catch {
-    return "unknown";
-  }
-}
 function disabledCodexMcpDetail(configPath) {
   return [
     "existing [mcp_servers.kyoso] is disabled and was kept unchanged.",
@@ -188743,75 +190016,146 @@ function disabledClaudeMcpDetail(configPath) {
 }
 function detectCodexMcp(path, cwd, home) {
   if (!existsSync2(path))
-    return { status: "missing", paths: [] };
+    return missingMcpDetection();
   try {
     const parsed = parse5(readTextSync(path));
     if (hasUnprobedProjectIntegrationOverride(parsed, cwd, home)) {
-      return { status: "unknown", paths: [path] };
+      return singleMcpDetection(manualMcpRegistration({
+        path,
+        scope: "codex-global",
+        status: "unknown",
+        value: undefined
+      }));
+    }
+    if (!isRecord10(parsed)) {
+      return singleMcpDetection(manualMcpRegistration({
+        path,
+        scope: "codex-global",
+        status: "unknown",
+        value: undefined
+      }));
     }
-    if (!isRecord9(parsed))
-      return { status: "unknown", paths: [path] };
     if (!("mcp_servers" in parsed))
-      return { status: "missing", paths: [] };
-    if (!isRecord9(parsed.mcp_servers)) {
-      return { status: "unknown", paths: [path] };
+      return missingMcpDetection();
+    if (!isRecord10(parsed.mcp_servers)) {
+      return singleMcpDetection(manualMcpRegistration({
+        path,
+        scope: "codex-global",
+        status: "unknown",
+        value: undefined
+      }));
     }
     if (!("kyoso" in parsed.mcp_servers)) {
-      return { status: "missing", paths: [] };
+      return missingMcpDetection();
     }
-    return { status: mcpEntryStatus(parsed.mcp_servers.kyoso), paths: [path] };
+    return singleMcpDetection(manualMcpRegistration({
+      path,
+      scope: "codex-global",
+      status: mcpEntryStatus(parsed.mcp_servers.kyoso),
+      value: parsed.mcp_servers.kyoso
+    }));
   } catch {
-    return { status: "unknown", paths: [path] };
+    return singleMcpDetection(manualMcpRegistration({
+      path,
+      scope: "codex-global",
+      status: "unknown",
+      value: undefined
+    }));
   }
 }
 function detectClaudeMcp(path, cwd, home) {
   if (!existsSync2(path))
-    return { status: "missing", paths: [] };
+    return missingMcpDetection();
   try {
     const parsed = JSON.parse(readTextSync(path));
-    const statuses = jsonMcpStatuses(parsed, cwd, home);
-    if (statuses.length === 0)
-      return { status: "missing", paths: [] };
-    return { status: mergeMcpStatuses(statuses), paths: [path] };
+    const registrations = jsonMcpRegistrations(parsed, path, cwd, home);
+    return registrations.length === 0 ? missingMcpDetection() : mergeMcpDetections([
+      {
+        status: mergeMcpStatuses(registrations.map((entry) => entry.status)),
+        paths: [path],
+        registrations
+      }
+    ]);
   } catch {
-    return { status: "unknown", paths: [path] };
+    return singleMcpDetection(manualMcpRegistration({
+      path,
+      scope: path.endsWith(".mcp.json") ? "claude-project" : "claude-global",
+      status: "unknown",
+      value: undefined
+    }));
   }
 }
-function jsonMcpStatuses(value, cwd, home) {
-  if (!isRecord9(value))
-    return ["unknown"];
-  const statuses = directMcpStatuses(value);
+function jsonMcpRegistrations(value, path, cwd, home) {
+  const directScope = path.endsWith(".mcp.json") ? "claude-project" : "claude-global";
+  if (!isRecord10(value)) {
+    return [
+      manualMcpRegistration({
+        path,
+        scope: directScope,
+        status: "unknown",
+        value: undefined
+      })
+    ];
+  }
+  const registrations = directMcpRegistrations(value, path, directScope);
   if (!("projects" in value))
-    return statuses;
-  if (!isRecord9(value.projects))
-    return [...statuses, "unknown"];
+    return registrations;
+  if (!isRecord10(value.projects)) {
+    return [
+      ...registrations,
+      manualMcpRegistration({
+        path,
+        scope: "claude-global-project",
+        status: "unknown",
+        value: undefined
+      })
+    ];
+  }
   const currentProject = normalizeProjectPath(cwd, home);
   for (const [projectPath, projectConfig] of Object.entries(value.projects)) {
     if (normalizeProjectPath(projectPath, home) !== currentProject)
       continue;
-    if (!isRecord9(projectConfig)) {
-      statuses.push("unknown");
+    if (!isRecord10(projectConfig)) {
+      registrations.push(manualMcpRegistration({
+        path,
+        scope: "claude-global-project",
+        status: "unknown",
+        value: undefined
+      }));
       continue;
     }
-    statuses.push(...directMcpStatuses(projectConfig));
+    registrations.push(...directMcpRegistrations(projectConfig, path, "claude-global-project"));
   }
-  return statuses;
+  return registrations;
 }
-function directMcpStatuses(value) {
-  const statuses = [];
-  if ("mcpServers" in value) {
-    if (!isRecord9(value.mcpServers)) {
-      statuses.push("unknown");
-    } else if ("kyoso" in value.mcpServers) {
-      statuses.push(mcpEntryStatus(value.mcpServers.kyoso));
-    }
+function directMcpRegistrations(value, path, scope) {
+  if (!("mcpServers" in value))
+    return [];
+  if (!isRecord10(value.mcpServers)) {
+    return [
+      manualMcpRegistration({
+        path,
+        scope,
+        status: "unknown",
+        value: undefined
+      })
+    ];
   }
-  return statuses;
+  if (!("kyoso" in value.mcpServers))
+    return [];
+  return [
+    manualMcpRegistration({
+      path,
+      scope,
+      status: mcpEntryStatus(value.mcpServers.kyoso),
+      value: value.mcpServers.kyoso
+    })
+  ];
 }
 function nestedMcpEntryStatus(value, path) {
   let current = value;
   for (const key of path) {
-    if (!isRecord9(current))
+    if (!isRecord10(current))
       return "unknown";
     if (!(key in current))
       return "missing";
@@ -188820,11 +190164,11 @@ function nestedMcpEntryStatus(value, path) {
   return mcpEntryStatus(current);
 }
 function hasUnprobedProjectIntegrationOverride(value, cwd, home) {
-  if (!isRecord9(value) || !isRecord9(value.projects))
+  if (!isRecord10(value) || !isRecord10(value.projects))
     return false;
   const currentProject = normalizeProjectPath(cwd, home);
   for (const [projectPath, projectConfig] of Object.entries(value.projects)) {
-    if (normalizeProjectPath(projectPath, home) !== currentProject || !isRecord9(projectConfig)) {
+    if (normalizeProjectPath(projectPath, home) !== currentProject || !isRecord10(projectConfig)) {
       continue;
     }
     if ("mcp_servers" in projectConfig || "plugins" in projectConfig) {
@@ -188847,7 +190191,7 @@ function normalizeProjectPath(path, home) {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function mcpEntryStatus(value) {
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return "unknown";
   if (!("enabled" in value))
     return "enabled";
@@ -188858,11 +190202,28 @@ function mcpEntryStatus(value) {
   return "unknown";
 }
 function mergeMcpDetections(detections) {
+  const registrations = detections.flatMap((detection) => detection.registrations);
+  if (registrations.length === 0)
+    return missingMcpDetection();
+  return {
+    status: registrations.length === 1 ? registrations[0]?.status ?? "unknown" : "unknown",
+    paths: [...new Set(registrations.map((registration) => registration.path))],
+    registrations
+  };
+}
+function missingMcpDetection() {
+  return { status: "missing", paths: [], registrations: [] };
+}
+function singleMcpDetection(registration) {
   return {
-    status: mergeMcpStatuses(detections.map((detection) => detection.status)),
-    paths: detections.flatMap((detection) => detection.paths)
+    status: registration.status,
+    paths: [registration.path],
+    registrations: [registration]
   };
 }
+function isCurrentManualMcp(detection) {
+  return detection.status === "enabled" && detection.registrations.length === 1 && detection.registrations[0]?.invocation.kind === "current";
+}
 function mergeMcpStatuses(statuses) {
   if (statuses.includes("enabled"))
     return "enabled";
@@ -188881,7 +190242,7 @@ function readTextSync(path) {
 function recordValue(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function diffForAppend(path, snippet) {
@@ -189010,8 +190371,8 @@ async function runDoctor(options) {
   });
   const claudeIntegration = determineClientIntegration("claude-code", setup["claude-code"], cli);
   lines.push("", "MCP", "  stdio server: ok");
-  lines.push(`  Codex registration: ${formatManualMcpStatus(setup.codex.manualMcpStatus)}`);
-  lines.push(`  Claude Code registration: ${formatManualMcpStatus(setup["claude-code"].manualMcpStatus)}`);
+  lines.push(`  Codex registration: ${formatManualMcpStatus(setup.codex, cli)}`);
+  lines.push(`  Claude Code registration: ${formatManualMcpStatus(setup["claude-code"], cli)}`);
   lines.push("", "Skills");
   lines.push(`  Codex kyoso-review: ${setup.codex.skill ? "ok" : "missing"}`);
   lines.push(`  Claude Code kyoso-review: ${setup["claude-code"].skill ? "ok" : "missing"}`);
@@ -189199,6 +190560,7 @@ function isCodexProjectProviderAllowlistIssue(_issue, path) {
 }
 function determineCodexIntegration(options) {
   const fallback = determineClientIntegration("codex", options.setup, options.cli);
+  const hasReadyManualMcp = fallback.mode === "manual-mcp" || fallback.mode === "mcp-only";
   const plugin = options.pluginInspector({
     cwd: options.cwd,
     env: options.env
@@ -189225,7 +190587,13 @@ function determineCodexIntegration(options) {
       "Plugin MCP origin is unknown because the manual MCP configuration could not be classified."
     ], "unknown", "unknown"), "installed, enabled", "unknown");
   }
-  if (options.setup.manualMcpStatus === "enabled" && override.status !== "disabled") {
+  if (options.setup.manualMcpStatus === "enabled" && !hasReadyManualMcp) {
+    return withPluginDetails(withIntegrationWarnings(fallback, [
+      ...pluginWarnings,
+      "Plugin MCP origin is unknown because an enabled manual MCP registration is legacy, custom, unverified, or its runner is unavailable."
+    ], "unknown", "unknown"), "installed, enabled", "unknown");
+  }
+  if (hasReadyManualMcp && override.status !== "disabled") {
     return withPluginDetails(withIntegrationWarnings({
       ...fallback,
       mode: "manual-mcp",
@@ -189242,7 +190610,7 @@ function determineCodexIntegration(options) {
       "Plugin MCP override could not be safely classified from the Codex configuration."
     ], "unknown", "unknown"), "installed, enabled", "unknown");
   }
-  if (override.status === "disabled" && options.setup.manualMcpStatus === "enabled") {
+  if (override.status === "disabled" && hasReadyManualMcp) {
     return withPluginDetails(withIntegrationWarnings({
       ...fallback,
       mode: "manual-mcp",
@@ -189306,6 +190674,7 @@ function determineCodexIntegration(options) {
 function determineClientIntegration(client, setup, cli) {
   const integration = determineNonPluginIntegration({
     manualMcpStatus: setup.manualMcpStatus,
+    manualMcpRegistrations: setup.manualMcpRegistrations,
     hasSkill: setup.skill,
     cli
   });
@@ -189341,7 +190710,7 @@ function pluginSkillWarnings(setup) {
 }
 function appendIntegration(lines, integration) {
   lines.push(`  ${integration.client} integration: ${integration.mode}`);
-  lines.push(`    manual MCP: ${formatManualMcpStatus(integration.setup.manualMcpStatus)}`);
+  lines.push(`    manual MCP: ${formatManualMcpStatus(integration.setup, integration.cli)}`);
   if (integration.setup.mcpPaths.length > 0) {
     lines.push(`    manual MCP path(s): ${integration.setup.mcpPaths.join(", ")}`);
   }
@@ -189350,8 +190719,8 @@ function appendIntegration(lines, integration) {
     lines.push(`    manual Skill path(s): ${integration.setup.skillPaths.join(", ")}`);
   }
   lines.push(`    CLI: ${formatCliAvailability(integration.cli.kyoso)}`);
-  lines.push(`    npx: ${integration.cli.npx ? "available" : "missing"}`);
-  lines.push(`    bunx: ${integration.cli.bunx ? "available" : "missing"}`);
+  lines.push(`    npx: ${formatRunnerAvailability(integration.cli.npx)}`);
+  lines.push(`    bunx: ${formatRunnerAvailability(integration.cli.bunx)}`);
   if (integration.plugin)
     lines.push(`    Plugin: ${integration.plugin}`);
   if (integration.pluginMcp) {
@@ -189362,10 +190731,26 @@ function appendIntegration(lines, integration) {
   }
   lines.push(`    ${integration.advice}`);
 }
-function formatManualMcpStatus(status) {
-  if (status === "enabled")
-    return "ok";
-  return status;
+function formatManualMcpStatus(setup, cli) {
+  if (setup.manualMcpStatus !== "enabled")
+    return setup.manualMcpStatus;
+  if (setup.manualMcpRegistrations.length !== 1)
+    return "unknown";
+  const invocation = setup.manualMcpRegistrations[0]?.invocation;
+  if (invocation?.kind === "current") {
+    if (invocation.runner === "npx") {
+      return cli.npx === "available" ? "ok" : "npx missing";
+    }
+    if (invocation.runner === "bunx") {
+      return cli.bunx === "missing" ? "bunx missing" : "bunx unverified";
+    }
+    return "unknown";
+  }
+  if (invocation?.kind === "legacy")
+    return "repair required (legacy)";
+  if (invocation?.kind === "custom")
+    return "custom/unverified";
+  return "unknown";
 }
 function integrationAdvice(mode, client) {
   if (mode === "plugin-mcp" || mode === "manual-mcp") {
@@ -189381,7 +190766,10 @@ function integrationAdvice(mode, client) {
     return "status: runnable on demand; package-runner fallback may need network access.";
   }
   if (mode === "mcp-only") {
-    return `next: run \`npx @kyo-so/cli setup ${client} --write --skill-only\``;
+    return `next: run \`${formatKyosoPackageCommand({
+      runner: "npx",
+      cliArgs: ["setup", client, "--write", "--skill-only"]
+    })}\``;
   }
   if (mode === "cli-only") {
     return `next: run \`kyoso setup ${client} --write --skill-only\``;
@@ -189516,8 +190904,8 @@ Do not use this skill for every coding task. It is intended for deliberate revie
 `;
 
 // src/cli/openRouterAcpSmoke.ts
-import { mkdir as mkdir6, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
+import { mkdir as mkdir6, mkdtemp as mkdtemp2, rm as rm3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join8 } from "node:path";
 
 // src/acp/AcpAgentProcess.ts
@@ -191915,14 +193303,14 @@ var zGuardCreateElicitationResponseCancel = object({
 });
 // node_modules/@agentclientprotocol/sdk/dist/jsonrpc.js
 var CANCEL_REQUEST_METHOD = "$/cancel_request";
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function cancelRequestId(params) {
-  if (!isRecord10(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord11(params) || !isJsonRpcId(params["requestId"])) {
     return;
   }
   return params["requestId"];
@@ -192269,7 +193657,7 @@ class Connection {
     if (this.abortController.signal.aborted) {
       return;
     }
-    if (!isRecord10(message)) {
+    if (!isRecord11(message)) {
       console.error("Invalid message", { message });
       return;
     }
@@ -192362,7 +193750,7 @@ class Connection {
       pendingResponse.cleanup?.();
       if ("result" in response) {
         pendingResponse.resolve(response.result);
-      } else if ("error" in response && isRecord10(response.error)) {
+      } else if ("error" in response && isRecord11(response.error)) {
         const { code, message, data } = response.error;
         pendingResponse.reject(new RequestError(code, message, data));
       } else {
@@ -192572,7 +193960,7 @@ function ndJsonStream(output2, input2) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord10(message)) {
+            if (isRecord11(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -193981,7 +195369,7 @@ function isSeverity(value) {
   return typeof value === "string" && severities.includes(value);
 }
 function normalizeCisaSecureByDesign(value) {
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     return;
   const normalized = {};
   const customerSecurityOutcomes = normalizeGateStatus(value.customerSecurityOutcomes);
@@ -194022,7 +195410,7 @@ function isEvidenceQuality(value) {
   return typeof value === "string" && evidenceQualities.includes(value);
 }
 function isStrictAgentOpinion(value) {
-  if (!isRecord11(value) || !hasOnlyKeys(value, STRICT_ROOT_KEYS))
+  if (!isRecord12(value) || !hasOnlyKeys(value, STRICT_ROOT_KEYS))
     return false;
   if (typeof value.summary !== "string")
     return false;
@@ -194032,7 +195420,7 @@ function isStrictAgentOpinion(value) {
   return value.cisaSecureByDesign === undefined || isStrictCisaSecureByDesign(value.cisaSecureByDesign);
 }
 function isStrictFinding(value) {
-  if (!isRecord11(value) || !hasOnlyKeys(value, STRICT_FINDING_KEYS)) {
+  if (!isRecord12(value) || !hasOnlyKeys(value, STRICT_FINDING_KEYS)) {
     return false;
   }
   if (!isSeverity(value.severity) || !isCategory(value.category) || !isNonEmptyString(value.title) || !isNonEmptyString(value.evidence) || !isNonEmptyString(value.recommendation) || !isConfidence(value.confidence)) {
@@ -194044,11 +195432,11 @@ function isStrictFinding(value) {
   return true;
 }
 function isStrictFindingFiles(value) {
-  return Array.isArray(value) && value.every((item) => isRecord11(item) && hasOnlyKeys(item, STRICT_FILE_KEYS) && isNonEmptyString(item.path) && isOptionalLineNumber(item.lineStart) && isOptionalLineNumber(item.lineEnd));
+  return Array.isArray(value) && value.every((item) => isRecord12(item) && hasOnlyKeys(item, STRICT_FILE_KEYS) && isNonEmptyString(item.path) && isOptionalLineNumber(item.lineStart) && isOptionalLineNumber(item.lineEnd));
 }
 function isStrictEvidenceRefs(value) {
   return Array.isArray(value) && value.length <= MAX_EVIDENCE_REFS2 && value.every((item) => {
-    if (!isRecord11(item) || !hasOnlyKeys(item, STRICT_EVIDENCE_REF_KEYS)) {
+    if (!isRecord12(item) || !hasOnlyKeys(item, STRICT_EVIDENCE_REF_KEYS)) {
       return false;
     }
     if (item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
@@ -194064,7 +195452,7 @@ function isStrictEvidenceRefs(value) {
   });
 }
 function isStrictCisaSecureByDesign(value) {
-  if (!isRecord11(value) || !hasOnlyKeys(value, STRICT_CISA_KEYS))
+  if (!isRecord12(value) || !hasOnlyKeys(value, STRICT_CISA_KEYS))
     return false;
   for (const key of [
     "customerSecurityOutcomes",
@@ -194103,7 +195491,7 @@ function normalizeFindingFiles(value) {
   if (!Array.isArray(value))
     return;
   const files = value.flatMap((item) => {
-    if (!isRecord11(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
+    if (!isRecord12(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
       return [];
     }
     const file2 = {
@@ -194123,7 +195511,7 @@ function normalizeEvidenceRefs2(value) {
   if (!Array.isArray(value))
     return;
   const references = value.slice(0, MAX_EVIDENCE_REFS2).flatMap((item) => {
-    if (!isRecord11(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
+    if (!isRecord12(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
       return [];
     }
     const reference = { kind: item.kind };
@@ -194146,7 +195534,7 @@ function normalizeEvidenceRefs2(value) {
 function normalizeLineNumber(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= MAX_EVIDENCE_LINE2 ? value : undefined;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -194554,7 +195942,7 @@ function normalizeUsage3(usage) {
   return normalizeModelTokenUsage(usage);
 }
 function withReportedExecutionIdentity(identity, metadata) {
-  const record2 = isRecord12(metadata) ? metadata : {};
+  const record2 = isRecord13(metadata) ? metadata : {};
   return createModelExecutionIdentity({
     providerRoute: identity.providerRoute,
     requestedModel: identity.requestedModel,
@@ -194562,7 +195950,7 @@ function withReportedExecutionIdentity(identity, metadata) {
     reportedModel: record2.model
   });
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function resolveEffortConfigOption(agent, effort) {
@@ -194764,7 +196152,7 @@ async function runOpenRouterCodexAcpSmoke(options = {}) {
   const env = options.env ?? process.env;
   const { model } = validateOpenRouterCodexAcpSmoke(env);
   const config2 = createOpenRouterCodexAcpSmokeConfig(model);
-  const smokeRoot = await mkdtemp2(join8(tmpdir2(), "kyoso-openrouter-acp-smoke-"));
+  const smokeRoot = await mkdtemp2(join8(tmpdir3(), "kyoso-openrouter-acp-smoke-"));
   const workspaceDir = join8(smokeRoot, "workspace");
   const homeDir = join8(smokeRoot, "home");
   const codexHomeDir = join8(smokeRoot, "codex-home");
@@ -194808,7 +196196,7 @@ async function runOpenRouterCodexAcpSmoke(options = {}) {
     }
     return "OpenRouter Codex ACP smoke passed.";
   } finally {
-    await rm2(smokeRoot, { recursive: true, force: true });
+    await rm3(smokeRoot, { recursive: true, force: true });
   }
 }
 function assertUsableEnvironmentValue(env, key) {
@@ -208825,7 +210213,7 @@ function clearInheritedOpenRouterModelForProviderReset(baseConfig, overridden, o
     return;
   }
   const codex = readPath2(overridden, ["agents", "codex"]);
-  if (isRecord13(codex))
+  if (isRecord14(codex))
     delete codex.model;
 }
 function findAssignmentForPath(overrides, path) {
@@ -208870,7 +210258,7 @@ function parseConfigOverrideValue(value, currentValue) {
 function readPath2(target, path) {
   let current = target;
   for (const key of path) {
-    if (!isRecord13(current))
+    if (!isRecord14(current))
       return;
     current = current[key];
   }
@@ -208880,7 +210268,7 @@ function writePath2(target, path, value) {
   let current = target;
   for (const key of path.slice(0, -1)) {
     const child = current[key];
-    if (!isRecord13(child)) {
+    if (!isRecord14(child)) {
       throw new Error(`Cannot apply --set key ${JSON.stringify(path.join("."))}.`);
     }
     current = child;
@@ -208889,7 +210277,7 @@ function writePath2(target, path, value) {
   if (leaf)
     current[leaf] = value;
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -209594,7 +210982,7 @@ function normalizeTitle(value) {
 
 // src/audit/safeTraceFile.ts
 import { constants as constants2 } from "node:fs";
-import { lstat as lstat3, open, realpath as realpath5, stat } from "node:fs/promises";
+import { lstat as lstat4, open as open2, realpath as realpath5, stat } from "node:fs/promises";
 import { join as join9 } from "node:path";
 var AUDIT_WARNING_UNSUPPORTED_OPEN_CAPABILITY = "AUDIT_DISABLED_UNSUPPORTED_CAPABILITY: Audit trace writing requires unavailable filesystem capabilities.";
 async function openVerifiedTraceFile(options) {
@@ -209619,7 +211007,7 @@ async function openVerifiedTraceFile(options) {
     throw new Error("trace path already exists");
   }
   await options.beforeOpen?.(tracePath);
-  const handle = await open(tracePath, flags, 384);
+  const handle = await open2(tracePath, flags, 384);
   try {
     const [handleStat, pathStat, realTracePath] = await Promise.all([
       handle.stat({ bigint: true }),
@@ -209657,7 +211045,7 @@ function isSafeTraceId(traceId) {
 }
 async function optionalLstat3(path) {
   try {
-    return await lstat3(path);
+    return await lstat4(path);
   } catch (error51) {
     if (typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT") {
       return;
@@ -209971,7 +211359,7 @@ function validateReviewContract(request) {
   const contract = request.reviewContract;
   if (contract === undefined)
     return;
-  if (!isRecord14(contract)) {
+  if (!isRecord15(contract)) {
     throw new KyosoRequestError("reviewContract must be an object", "VALIDATION_ERROR");
   }
   const allowedKeys = new Set(["focus", "nonGoals", "acceptedRisks"]);
@@ -209988,7 +211376,7 @@ function validateReviewContract(request) {
     throw new KyosoRequestError("reviewContract.nonGoals must contain at most 20 non-empty strings of 500 characters or fewer", "VALIDATION_ERROR");
   }
   const acceptedRisks = contract.acceptedRisks;
-  if (acceptedRisks !== undefined && (!Array.isArray(acceptedRisks) || acceptedRisks.length > 20 || acceptedRisks.some((risk) => !isRecord14(risk) || typeof risk.findingFingerprint !== "string" || !/^sha256:[0-9a-f]{64}$/.test(risk.findingFingerprint) || typeof risk.rationale !== "string" || risk.rationale.trim().length === 0 || risk.rationale.length > 500))) {
+  if (acceptedRisks !== undefined && (!Array.isArray(acceptedRisks) || acceptedRisks.length > 20 || acceptedRisks.some((risk) => !isRecord15(risk) || typeof risk.findingFingerprint !== "string" || !/^sha256:[0-9a-f]{64}$/.test(risk.findingFingerprint) || typeof risk.rationale !== "string" || risk.rationale.trim().length === 0 || risk.rationale.length > 500))) {
     throw new KyosoRequestError("reviewContract.acceptedRisks must contain valid finding fingerprints and bounded rationales", "VALIDATION_ERROR");
   }
 }
@@ -210000,13 +211388,13 @@ function validateSelectedFiles(request) {
     throw new KyosoRequestError("selectedFiles must be an array", "VALIDATION_ERROR");
   }
   for (const file2 of selectedFiles) {
-    if (!isRecord14(file2) || typeof file2.path !== "string" || file2.path.trim().length === 0 || typeof file2.content !== "string" || file2.language !== undefined && typeof file2.language !== "string" || file2.truncated !== undefined && typeof file2.truncated !== "boolean") {
+    if (!isRecord15(file2) || typeof file2.path !== "string" || file2.path.trim().length === 0 || typeof file2.content !== "string" || file2.language !== undefined && typeof file2.language !== "string" || file2.truncated !== undefined && typeof file2.truncated !== "boolean") {
       throw new KyosoRequestError("selectedFiles entries require string path/content and valid optional metadata", "VALIDATION_ERROR");
     }
     normalizeRelativePath(file2.path);
   }
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -210431,11 +211819,11 @@ function decide(input2) {
 }
 
 // src/workspace/createSnapshot.ts
-import { chmod, mkdir as mkdir7, mkdtemp as mkdtemp3, writeFile as writeFile6 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir7, mkdtemp as mkdtemp3, writeFile as writeFile6 } from "node:fs/promises";
 import { dirname as dirname9, join as join10 } from "node:path";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 async function createSnapshot(traceId, tool, request, options = {}) {
-  const root = await mkdtemp3(join10(tmpdir3(), `kyoso-${traceId}-`));
+  const root = await mkdtemp3(join10(tmpdir4(), `kyoso-${traceId}-`));
   const repoDir = join10(root, "repo");
   const contextDir = join10(root, "context");
   await mkdir7(repoDir, { recursive: true });
@@ -210450,7 +211838,7 @@ async function createSnapshot(traceId, tool, request, options = {}) {
     const dest = join10(repoDir, relative4);
     await mkdir7(dirname9(dest), { recursive: true });
     await writeFile6(dest, file2.content, "utf8");
-    await chmod(dest, 292).catch(() => {
+    await chmod2(dest, 292).catch(() => {
       return;
     });
     fileCount += 1;
@@ -210486,17 +211874,17 @@ function buildSelectedFilesManifest(request) {
 }
 
 // src/workspace/cleanup.ts
-import { rm as rm3 } from "node:fs/promises";
+import { rm as rm4 } from "node:fs/promises";
 async function cleanupSnapshot(path) {
   if (process.env.KYOSO_KEEP_TEMP === "1")
     return;
-  await rm3(path, { recursive: true, force: true });
+  await rm4(path, { recursive: true, force: true });
 }
 
 // src/utils/ids.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 function newTraceId() {
-  return `tr_${randomUUID2()}`;
+  return `tr_${randomUUID3()}`;
 }
 
 // src/core/requestFingerprint.ts
@@ -210537,11 +211925,11 @@ function canonicalJson(value) {
 function canonicalize(value) {
   if (Array.isArray(value))
     return value.map(canonicalize);
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return value;
   return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== undefined).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, canonicalize(child)]));
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -210555,7 +211943,7 @@ var REVIEW_BUDGET_KEYS = new Set([
 ]);
 var MODEL_CALL_KINDS = ["primary", "verifier", "judge"];
 function resolveReviewBudget(ceiling, requested) {
-  if (requested !== undefined && !isRecord16(requested)) {
+  if (requested !== undefined && !isRecord17(requested)) {
     throw new KyosoRequestError("options.reviewBudget must be an object.", "REVIEW_BUDGET_INVALID");
   }
   for (const [key, value] of Object.entries(requested ?? {})) {
@@ -210899,7 +212287,7 @@ function emptyReviewModelCallPlan() {
     ceilingEffects: []
   };
 }
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -210961,7 +212349,7 @@ function parseVerificationVerdicts(rawText) {
     if (!Array.isArray(parsed.verdicts))
       return;
     return parsed.verdicts.flatMap((item) => {
-      if (!isRecord17(item))
+      if (!isRecord18(item))
         return [];
       if (typeof item.findingId !== "string")
         return [];
@@ -211039,7 +212427,7 @@ function verificationNote(reasoning) {
 function isVerdict(value) {
   return value === "confirmed" || value === "refuted" || value === "uncertain";
 }
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }